@aws-sdk/client-rds 3.1068.0 → 3.1069.0

package/dist-cjs/index.js

@@ -1,19 +1,22 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var 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 middlewareSdkRds = require('@aws-sdk/middleware-sdk-rds');
-var errors = require('./models/errors');
-var RDSServiceException = require('./models/RDSServiceException');
+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, defaultRDSHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { AddRoleToDBCluster$, AddRoleToDBInstance$, AddSourceIdentifierToSubscription$, AddTagsToResource$, ApplyPendingMaintenanceAction$, AuthorizeDBSecurityGroupIngress$, BacktrackDBCluster$, CancelExportTask$, CopyDBClusterParameterGroup$, CopyDBClusterSnapshot$, CopyDBParameterGroup$, CopyDBSnapshot$, CopyOptionGroup$, CreateBlueGreenDeployment$, CreateCustomDBEngineVersion$, CreateDBCluster$, CreateDBClusterEndpoint$, CreateDBClusterParameterGroup$, CreateDBClusterSnapshot$, CreateDBInstance$, CreateDBInstanceReadReplica$, CreateDBParameterGroup$, CreateDBProxy$, CreateDBProxyEndpoint$, CreateDBSecurityGroup$, CreateDBShardGroup$, CreateDBSnapshot$, CreateDBSubnetGroup$, CreateEventSubscription$, CreateGlobalCluster$, CreateIntegration$, CreateOptionGroup$, CreateTenantDatabase$, DeleteBlueGreenDeployment$, DeleteCustomDBEngineVersion$, DeleteDBClusterAutomatedBackup$, DeleteDBCluster$, DeleteDBClusterEndpoint$, DeleteDBClusterParameterGroup$, DeleteDBClusterSnapshot$, DeleteDBInstanceAutomatedBackup$, DeleteDBInstance$, DeleteDBParameterGroup$, DeleteDBProxy$, DeleteDBProxyEndpoint$, DeleteDBSecurityGroup$, DeleteDBShardGroup$, DeleteDBSnapshot$, DeleteDBSubnetGroup$, DeleteEventSubscription$, DeleteGlobalCluster$, DeleteIntegration$, DeleteOptionGroup$, DeleteTenantDatabase$, DeregisterDBProxyTargets$, DescribeAccountAttributes$, DescribeBlueGreenDeployments$, DescribeCertificates$, DescribeDBClusterAutomatedBackups$, DescribeDBClusterBacktracks$, DescribeDBClusterEndpoints$, DescribeDBClusterParameterGroups$, DescribeDBClusterParameters$, DescribeDBClusters$, DescribeDBClusterSnapshotAttributes$, DescribeDBClusterSnapshots$, DescribeDBEngineVersions$, DescribeDBInstanceAutomatedBackups$, DescribeDBInstances$, DescribeDBLogFiles$, DescribeDBMajorEngineVersions$, DescribeDBParameterGroups$, DescribeDBParameters$, DescribeDBProxies$, DescribeDBProxyEndpoints$, DescribeDBProxyTargetGroups$, DescribeDBProxyTargets$, DescribeDBRecommendations$, DescribeDBSecurityGroups$, DescribeDBShardGroups$, DescribeDBSnapshotAttributes$, DescribeDBSnapshots$, DescribeDBSnapshotTenantDatabases$, DescribeDBSubnetGroups$, DescribeEngineDefaultClusterParameters$, DescribeEngineDefaultParameters$, DescribeEventCategories$, DescribeEvents$, DescribeEventSubscriptions$, DescribeExportTasks$, DescribeGlobalClusters$, DescribeIntegrations$, DescribeOptionGroupOptions$, DescribeOptionGroups$, DescribeOrderableDBInstanceOptions$, DescribePendingMaintenanceActions$, DescribeReservedDBInstances$, DescribeReservedDBInstancesOfferings$, DescribeServerlessV2PlatformVersions$, DescribeSourceRegions$, DescribeTenantDatabases$, DescribeValidDBInstanceModifications$, DisableHttpEndpoint$, DownloadDBLogFilePortion$, EnableHttpEndpoint$, FailoverDBCluster$, FailoverGlobalCluster$, ListTagsForResource$, ModifyActivityStream$, ModifyCertificates$, ModifyCurrentDBClusterCapacity$, ModifyCustomDBEngineVersion$, ModifyDBCluster$, ModifyDBClusterEndpoint$, ModifyDBClusterParameterGroup$, ModifyDBClusterSnapshotAttribute$, ModifyDBInstance$, ModifyDBParameterGroup$, ModifyDBProxy$, ModifyDBProxyEndpoint$, ModifyDBProxyTargetGroup$, ModifyDBRecommendation$, ModifyDBShardGroup$, ModifyDBSnapshotAttribute$, ModifyDBSnapshot$, ModifyDBSubnetGroup$, ModifyEventSubscription$, ModifyGlobalCluster$, ModifyIntegration$, ModifyOptionGroup$, ModifyTenantDatabase$, PromoteReadReplica$, PromoteReadReplicaDBCluster$, PurchaseReservedDBInstancesOffering$, RebootDBCluster$, RebootDBInstance$, RebootDBShardGroup$, RegisterDBProxyTargets$, RemoveFromGlobalCluster$, RemoveRoleFromDBCluster$, RemoveRoleFromDBInstance$, RemoveSourceIdentifierFromSubscription$, RemoveTagsFromResource$, ResetDBClusterParameterGroup$, ResetDBParameterGroup$, RestoreDBClusterFromS3$, RestoreDBClusterFromSnapshot$, RestoreDBClusterToPointInTime$, RestoreDBInstanceFromDBSnapshot$, RestoreDBInstanceFromS3$, RestoreDBInstanceToPointInTime$, RevokeDBSecurityGroupIngress$, StartActivityStream$, StartDBCluster$, StartDBInstanceAutomatedBackupsReplication$, StartDBInstance$, StartExportTask$, StopActivityStream$, StopDBCluster$, StopDBInstanceAutomatedBackupsReplication$, StopDBInstance$, SwitchoverBlueGreenDeployment$, SwitchoverGlobalCluster$, SwitchoverReadReplica$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+const { getCrossRegionPresignedUrlPlugin } = require("@aws-sdk/middleware-sdk-rds");
+__exportStar(require("./models/errors"), exports);
+const { RDSServiceException } = require("./models/RDSServiceException");
+exports.RDSServiceException = RDSServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -69,2117 +72,2117 @@ 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 RDSClient extends client.Client {
+class RDSClient 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.defaultRDSHttpAuthSchemeParametersProvider,
-            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: defaultRDSHttpAuthSchemeParametersProvider,
+            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 AddRoleToDBClusterCommand extends client.Command
+class AddRoleToDBClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "AddRoleToDBCluster", {})
     .n("RDSClient", "AddRoleToDBClusterCommand")
-    .sc(schemas_0.AddRoleToDBCluster$)
+    .sc(AddRoleToDBCluster$)
     .build() {
 }
 
-class AddRoleToDBInstanceCommand extends client.Command
+class AddRoleToDBInstanceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "AddRoleToDBInstance", {})
     .n("RDSClient", "AddRoleToDBInstanceCommand")
-    .sc(schemas_0.AddRoleToDBInstance$)
+    .sc(AddRoleToDBInstance$)
     .build() {
 }
 
-class AddSourceIdentifierToSubscriptionCommand extends client.Command
+class AddSourceIdentifierToSubscriptionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "AddSourceIdentifierToSubscription", {})
     .n("RDSClient", "AddSourceIdentifierToSubscriptionCommand")
-    .sc(schemas_0.AddSourceIdentifierToSubscription$)
+    .sc(AddSourceIdentifierToSubscription$)
     .build() {
 }
 
-class AddTagsToResourceCommand extends client.Command
+class AddTagsToResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "AddTagsToResource", {})
     .n("RDSClient", "AddTagsToResourceCommand")
-    .sc(schemas_0.AddTagsToResource$)
+    .sc(AddTagsToResource$)
     .build() {
 }
 
-class ApplyPendingMaintenanceActionCommand extends client.Command
+class ApplyPendingMaintenanceActionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ApplyPendingMaintenanceAction", {})
     .n("RDSClient", "ApplyPendingMaintenanceActionCommand")
-    .sc(schemas_0.ApplyPendingMaintenanceAction$)
+    .sc(ApplyPendingMaintenanceAction$)
     .build() {
 }
 
-class AuthorizeDBSecurityGroupIngressCommand extends client.Command
+class AuthorizeDBSecurityGroupIngressCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "AuthorizeDBSecurityGroupIngress", {})
     .n("RDSClient", "AuthorizeDBSecurityGroupIngressCommand")
-    .sc(schemas_0.AuthorizeDBSecurityGroupIngress$)
+    .sc(AuthorizeDBSecurityGroupIngress$)
     .build() {
 }
 
-class BacktrackDBClusterCommand extends client.Command
+class BacktrackDBClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "BacktrackDBCluster", {})
     .n("RDSClient", "BacktrackDBClusterCommand")
-    .sc(schemas_0.BacktrackDBCluster$)
+    .sc(BacktrackDBCluster$)
     .build() {
 }
 
-class CancelExportTaskCommand extends client.Command
+class CancelExportTaskCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CancelExportTask", {})
     .n("RDSClient", "CancelExportTaskCommand")
-    .sc(schemas_0.CancelExportTask$)
+    .sc(CancelExportTask$)
     .build() {
 }
 
-class CopyDBClusterParameterGroupCommand extends client.Command
+class CopyDBClusterParameterGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CopyDBClusterParameterGroup", {})
     .n("RDSClient", "CopyDBClusterParameterGroupCommand")
-    .sc(schemas_0.CopyDBClusterParameterGroup$)
+    .sc(CopyDBClusterParameterGroup$)
     .build() {
 }
 
-class CopyDBClusterSnapshotCommand extends client.Command
+class CopyDBClusterSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-        middlewareSdkRds.getCrossRegionPresignedUrlPlugin(config),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getCrossRegionPresignedUrlPlugin(config),
     ];
 })
     .s("AmazonRDSv19", "CopyDBClusterSnapshot", {})
     .n("RDSClient", "CopyDBClusterSnapshotCommand")
-    .sc(schemas_0.CopyDBClusterSnapshot$)
+    .sc(CopyDBClusterSnapshot$)
     .build() {
 }
 
-class CopyDBParameterGroupCommand extends client.Command
+class CopyDBParameterGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CopyDBParameterGroup", {})
     .n("RDSClient", "CopyDBParameterGroupCommand")
-    .sc(schemas_0.CopyDBParameterGroup$)
+    .sc(CopyDBParameterGroup$)
     .build() {
 }
 
-class CopyDBSnapshotCommand extends client.Command
+class CopyDBSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-        middlewareSdkRds.getCrossRegionPresignedUrlPlugin(config),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getCrossRegionPresignedUrlPlugin(config),
     ];
 })
     .s("AmazonRDSv19", "CopyDBSnapshot", {})
     .n("RDSClient", "CopyDBSnapshotCommand")
-    .sc(schemas_0.CopyDBSnapshot$)
+    .sc(CopyDBSnapshot$)
     .build() {
 }
 
-class CopyOptionGroupCommand extends client.Command
+class CopyOptionGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CopyOptionGroup", {})
     .n("RDSClient", "CopyOptionGroupCommand")
-    .sc(schemas_0.CopyOptionGroup$)
+    .sc(CopyOptionGroup$)
     .build() {
 }
 
-class CreateBlueGreenDeploymentCommand extends client.Command
+class CreateBlueGreenDeploymentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateBlueGreenDeployment", {})
     .n("RDSClient", "CreateBlueGreenDeploymentCommand")
-    .sc(schemas_0.CreateBlueGreenDeployment$)
+    .sc(CreateBlueGreenDeployment$)
     .build() {
 }
 
-class CreateCustomDBEngineVersionCommand extends client.Command
+class CreateCustomDBEngineVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateCustomDBEngineVersion", {})
     .n("RDSClient", "CreateCustomDBEngineVersionCommand")
-    .sc(schemas_0.CreateCustomDBEngineVersion$)
+    .sc(CreateCustomDBEngineVersion$)
     .build() {
 }
 
-class CreateDBClusterCommand extends client.Command
+class CreateDBClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-        middlewareSdkRds.getCrossRegionPresignedUrlPlugin(config),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getCrossRegionPresignedUrlPlugin(config),
     ];
 })
     .s("AmazonRDSv19", "CreateDBCluster", {})
     .n("RDSClient", "CreateDBClusterCommand")
-    .sc(schemas_0.CreateDBCluster$)
+    .sc(CreateDBCluster$)
     .build() {
 }
 
-class CreateDBClusterEndpointCommand extends client.Command
+class CreateDBClusterEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateDBClusterEndpoint", {})
     .n("RDSClient", "CreateDBClusterEndpointCommand")
-    .sc(schemas_0.CreateDBClusterEndpoint$)
+    .sc(CreateDBClusterEndpoint$)
     .build() {
 }
 
-class CreateDBClusterParameterGroupCommand extends client.Command
+class CreateDBClusterParameterGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateDBClusterParameterGroup", {})
     .n("RDSClient", "CreateDBClusterParameterGroupCommand")
-    .sc(schemas_0.CreateDBClusterParameterGroup$)
+    .sc(CreateDBClusterParameterGroup$)
     .build() {
 }
 
-class CreateDBClusterSnapshotCommand extends client.Command
+class CreateDBClusterSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateDBClusterSnapshot", {})
     .n("RDSClient", "CreateDBClusterSnapshotCommand")
-    .sc(schemas_0.CreateDBClusterSnapshot$)
+    .sc(CreateDBClusterSnapshot$)
     .build() {
 }
 
-class CreateDBInstanceCommand extends client.Command
+class CreateDBInstanceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateDBInstance", {})
     .n("RDSClient", "CreateDBInstanceCommand")
-    .sc(schemas_0.CreateDBInstance$)
+    .sc(CreateDBInstance$)
     .build() {
 }
 
-class CreateDBInstanceReadReplicaCommand extends client.Command
+class CreateDBInstanceReadReplicaCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-        middlewareSdkRds.getCrossRegionPresignedUrlPlugin(config),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getCrossRegionPresignedUrlPlugin(config),
     ];
 })
     .s("AmazonRDSv19", "CreateDBInstanceReadReplica", {})
     .n("RDSClient", "CreateDBInstanceReadReplicaCommand")
-    .sc(schemas_0.CreateDBInstanceReadReplica$)
+    .sc(CreateDBInstanceReadReplica$)
     .build() {
 }
 
-class CreateDBParameterGroupCommand extends client.Command
+class CreateDBParameterGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateDBParameterGroup", {})
     .n("RDSClient", "CreateDBParameterGroupCommand")
-    .sc(schemas_0.CreateDBParameterGroup$)
+    .sc(CreateDBParameterGroup$)
     .build() {
 }
 
-class CreateDBProxyCommand extends client.Command
+class CreateDBProxyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateDBProxy", {})
     .n("RDSClient", "CreateDBProxyCommand")
-    .sc(schemas_0.CreateDBProxy$)
+    .sc(CreateDBProxy$)
     .build() {
 }
 
-class CreateDBProxyEndpointCommand extends client.Command
+class CreateDBProxyEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateDBProxyEndpoint", {})
     .n("RDSClient", "CreateDBProxyEndpointCommand")
-    .sc(schemas_0.CreateDBProxyEndpoint$)
+    .sc(CreateDBProxyEndpoint$)
     .build() {
 }
 
-class CreateDBSecurityGroupCommand extends client.Command
+class CreateDBSecurityGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateDBSecurityGroup", {})
     .n("RDSClient", "CreateDBSecurityGroupCommand")
-    .sc(schemas_0.CreateDBSecurityGroup$)
+    .sc(CreateDBSecurityGroup$)
     .build() {
 }
 
-class CreateDBShardGroupCommand extends client.Command
+class CreateDBShardGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateDBShardGroup", {})
     .n("RDSClient", "CreateDBShardGroupCommand")
-    .sc(schemas_0.CreateDBShardGroup$)
+    .sc(CreateDBShardGroup$)
     .build() {
 }
 
-class CreateDBSnapshotCommand extends client.Command
+class CreateDBSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateDBSnapshot", {})
     .n("RDSClient", "CreateDBSnapshotCommand")
-    .sc(schemas_0.CreateDBSnapshot$)
+    .sc(CreateDBSnapshot$)
     .build() {
 }
 
-class CreateDBSubnetGroupCommand extends client.Command
+class CreateDBSubnetGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateDBSubnetGroup", {})
     .n("RDSClient", "CreateDBSubnetGroupCommand")
-    .sc(schemas_0.CreateDBSubnetGroup$)
+    .sc(CreateDBSubnetGroup$)
     .build() {
 }
 
-class CreateEventSubscriptionCommand extends client.Command
+class CreateEventSubscriptionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateEventSubscription", {})
     .n("RDSClient", "CreateEventSubscriptionCommand")
-    .sc(schemas_0.CreateEventSubscription$)
+    .sc(CreateEventSubscription$)
     .build() {
 }
 
-class CreateGlobalClusterCommand extends client.Command
+class CreateGlobalClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateGlobalCluster", {})
     .n("RDSClient", "CreateGlobalClusterCommand")
-    .sc(schemas_0.CreateGlobalCluster$)
+    .sc(CreateGlobalCluster$)
     .build() {
 }
 
-class CreateIntegrationCommand extends client.Command
+class CreateIntegrationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateIntegration", {})
     .n("RDSClient", "CreateIntegrationCommand")
-    .sc(schemas_0.CreateIntegration$)
+    .sc(CreateIntegration$)
     .build() {
 }
 
-class CreateOptionGroupCommand extends client.Command
+class CreateOptionGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateOptionGroup", {})
     .n("RDSClient", "CreateOptionGroupCommand")
-    .sc(schemas_0.CreateOptionGroup$)
+    .sc(CreateOptionGroup$)
     .build() {
 }
 
-class CreateTenantDatabaseCommand extends client.Command
+class CreateTenantDatabaseCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "CreateTenantDatabase", {})
     .n("RDSClient", "CreateTenantDatabaseCommand")
-    .sc(schemas_0.CreateTenantDatabase$)
+    .sc(CreateTenantDatabase$)
     .build() {
 }
 
-class DeleteBlueGreenDeploymentCommand extends client.Command
+class DeleteBlueGreenDeploymentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteBlueGreenDeployment", {})
     .n("RDSClient", "DeleteBlueGreenDeploymentCommand")
-    .sc(schemas_0.DeleteBlueGreenDeployment$)
+    .sc(DeleteBlueGreenDeployment$)
     .build() {
 }
 
-class DeleteCustomDBEngineVersionCommand extends client.Command
+class DeleteCustomDBEngineVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteCustomDBEngineVersion", {})
     .n("RDSClient", "DeleteCustomDBEngineVersionCommand")
-    .sc(schemas_0.DeleteCustomDBEngineVersion$)
+    .sc(DeleteCustomDBEngineVersion$)
     .build() {
 }
 
-class DeleteDBClusterAutomatedBackupCommand extends client.Command
+class DeleteDBClusterAutomatedBackupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBClusterAutomatedBackup", {})
     .n("RDSClient", "DeleteDBClusterAutomatedBackupCommand")
-    .sc(schemas_0.DeleteDBClusterAutomatedBackup$)
+    .sc(DeleteDBClusterAutomatedBackup$)
     .build() {
 }
 
-class DeleteDBClusterCommand extends client.Command
+class DeleteDBClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBCluster", {})
     .n("RDSClient", "DeleteDBClusterCommand")
-    .sc(schemas_0.DeleteDBCluster$)
+    .sc(DeleteDBCluster$)
     .build() {
 }
 
-class DeleteDBClusterEndpointCommand extends client.Command
+class DeleteDBClusterEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBClusterEndpoint", {})
     .n("RDSClient", "DeleteDBClusterEndpointCommand")
-    .sc(schemas_0.DeleteDBClusterEndpoint$)
+    .sc(DeleteDBClusterEndpoint$)
     .build() {
 }
 
-class DeleteDBClusterParameterGroupCommand extends client.Command
+class DeleteDBClusterParameterGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBClusterParameterGroup", {})
     .n("RDSClient", "DeleteDBClusterParameterGroupCommand")
-    .sc(schemas_0.DeleteDBClusterParameterGroup$)
+    .sc(DeleteDBClusterParameterGroup$)
     .build() {
 }
 
-class DeleteDBClusterSnapshotCommand extends client.Command
+class DeleteDBClusterSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBClusterSnapshot", {})
     .n("RDSClient", "DeleteDBClusterSnapshotCommand")
-    .sc(schemas_0.DeleteDBClusterSnapshot$)
+    .sc(DeleteDBClusterSnapshot$)
     .build() {
 }
 
-class DeleteDBInstanceAutomatedBackupCommand extends client.Command
+class DeleteDBInstanceAutomatedBackupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBInstanceAutomatedBackup", {})
     .n("RDSClient", "DeleteDBInstanceAutomatedBackupCommand")
-    .sc(schemas_0.DeleteDBInstanceAutomatedBackup$)
+    .sc(DeleteDBInstanceAutomatedBackup$)
     .build() {
 }
 
-class DeleteDBInstanceCommand extends client.Command
+class DeleteDBInstanceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBInstance", {})
     .n("RDSClient", "DeleteDBInstanceCommand")
-    .sc(schemas_0.DeleteDBInstance$)
+    .sc(DeleteDBInstance$)
     .build() {
 }
 
-class DeleteDBParameterGroupCommand extends client.Command
+class DeleteDBParameterGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBParameterGroup", {})
     .n("RDSClient", "DeleteDBParameterGroupCommand")
-    .sc(schemas_0.DeleteDBParameterGroup$)
+    .sc(DeleteDBParameterGroup$)
     .build() {
 }
 
-class DeleteDBProxyCommand extends client.Command
+class DeleteDBProxyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBProxy", {})
     .n("RDSClient", "DeleteDBProxyCommand")
-    .sc(schemas_0.DeleteDBProxy$)
+    .sc(DeleteDBProxy$)
     .build() {
 }
 
-class DeleteDBProxyEndpointCommand extends client.Command
+class DeleteDBProxyEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBProxyEndpoint", {})
     .n("RDSClient", "DeleteDBProxyEndpointCommand")
-    .sc(schemas_0.DeleteDBProxyEndpoint$)
+    .sc(DeleteDBProxyEndpoint$)
     .build() {
 }
 
-class DeleteDBSecurityGroupCommand extends client.Command
+class DeleteDBSecurityGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBSecurityGroup", {})
     .n("RDSClient", "DeleteDBSecurityGroupCommand")
-    .sc(schemas_0.DeleteDBSecurityGroup$)
+    .sc(DeleteDBSecurityGroup$)
     .build() {
 }
 
-class DeleteDBShardGroupCommand extends client.Command
+class DeleteDBShardGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBShardGroup", {})
     .n("RDSClient", "DeleteDBShardGroupCommand")
-    .sc(schemas_0.DeleteDBShardGroup$)
+    .sc(DeleteDBShardGroup$)
     .build() {
 }
 
-class DeleteDBSnapshotCommand extends client.Command
+class DeleteDBSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBSnapshot", {})
     .n("RDSClient", "DeleteDBSnapshotCommand")
-    .sc(schemas_0.DeleteDBSnapshot$)
+    .sc(DeleteDBSnapshot$)
     .build() {
 }
 
-class DeleteDBSubnetGroupCommand extends client.Command
+class DeleteDBSubnetGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteDBSubnetGroup", {})
     .n("RDSClient", "DeleteDBSubnetGroupCommand")
-    .sc(schemas_0.DeleteDBSubnetGroup$)
+    .sc(DeleteDBSubnetGroup$)
     .build() {
 }
 
-class DeleteEventSubscriptionCommand extends client.Command
+class DeleteEventSubscriptionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteEventSubscription", {})
     .n("RDSClient", "DeleteEventSubscriptionCommand")
-    .sc(schemas_0.DeleteEventSubscription$)
+    .sc(DeleteEventSubscription$)
     .build() {
 }
 
-class DeleteGlobalClusterCommand extends client.Command
+class DeleteGlobalClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteGlobalCluster", {})
     .n("RDSClient", "DeleteGlobalClusterCommand")
-    .sc(schemas_0.DeleteGlobalCluster$)
+    .sc(DeleteGlobalCluster$)
     .build() {
 }
 
-class DeleteIntegrationCommand extends client.Command
+class DeleteIntegrationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteIntegration", {})
     .n("RDSClient", "DeleteIntegrationCommand")
-    .sc(schemas_0.DeleteIntegration$)
+    .sc(DeleteIntegration$)
     .build() {
 }
 
-class DeleteOptionGroupCommand extends client.Command
+class DeleteOptionGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteOptionGroup", {})
     .n("RDSClient", "DeleteOptionGroupCommand")
-    .sc(schemas_0.DeleteOptionGroup$)
+    .sc(DeleteOptionGroup$)
     .build() {
 }
 
-class DeleteTenantDatabaseCommand extends client.Command
+class DeleteTenantDatabaseCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeleteTenantDatabase", {})
     .n("RDSClient", "DeleteTenantDatabaseCommand")
-    .sc(schemas_0.DeleteTenantDatabase$)
+    .sc(DeleteTenantDatabase$)
     .build() {
 }
 
-class DeregisterDBProxyTargetsCommand extends client.Command
+class DeregisterDBProxyTargetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DeregisterDBProxyTargets", {})
     .n("RDSClient", "DeregisterDBProxyTargetsCommand")
-    .sc(schemas_0.DeregisterDBProxyTargets$)
+    .sc(DeregisterDBProxyTargets$)
     .build() {
 }
 
-class DescribeAccountAttributesCommand extends client.Command
+class DescribeAccountAttributesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeAccountAttributes", {})
     .n("RDSClient", "DescribeAccountAttributesCommand")
-    .sc(schemas_0.DescribeAccountAttributes$)
+    .sc(DescribeAccountAttributes$)
     .build() {
 }
 
-class DescribeBlueGreenDeploymentsCommand extends client.Command
+class DescribeBlueGreenDeploymentsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeBlueGreenDeployments", {})
     .n("RDSClient", "DescribeBlueGreenDeploymentsCommand")
-    .sc(schemas_0.DescribeBlueGreenDeployments$)
+    .sc(DescribeBlueGreenDeployments$)
     .build() {
 }
 
-class DescribeCertificatesCommand extends client.Command
+class DescribeCertificatesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeCertificates", {})
     .n("RDSClient", "DescribeCertificatesCommand")
-    .sc(schemas_0.DescribeCertificates$)
+    .sc(DescribeCertificates$)
     .build() {
 }
 
-class DescribeDBClusterAutomatedBackupsCommand extends client.Command
+class DescribeDBClusterAutomatedBackupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBClusterAutomatedBackups", {})
     .n("RDSClient", "DescribeDBClusterAutomatedBackupsCommand")
-    .sc(schemas_0.DescribeDBClusterAutomatedBackups$)
+    .sc(DescribeDBClusterAutomatedBackups$)
     .build() {
 }
 
-class DescribeDBClusterBacktracksCommand extends client.Command
+class DescribeDBClusterBacktracksCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBClusterBacktracks", {})
     .n("RDSClient", "DescribeDBClusterBacktracksCommand")
-    .sc(schemas_0.DescribeDBClusterBacktracks$)
+    .sc(DescribeDBClusterBacktracks$)
     .build() {
 }
 
-class DescribeDBClusterEndpointsCommand extends client.Command
+class DescribeDBClusterEndpointsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBClusterEndpoints", {})
     .n("RDSClient", "DescribeDBClusterEndpointsCommand")
-    .sc(schemas_0.DescribeDBClusterEndpoints$)
+    .sc(DescribeDBClusterEndpoints$)
     .build() {
 }
 
-class DescribeDBClusterParameterGroupsCommand extends client.Command
+class DescribeDBClusterParameterGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBClusterParameterGroups", {})
     .n("RDSClient", "DescribeDBClusterParameterGroupsCommand")
-    .sc(schemas_0.DescribeDBClusterParameterGroups$)
+    .sc(DescribeDBClusterParameterGroups$)
     .build() {
 }
 
-class DescribeDBClusterParametersCommand extends client.Command
+class DescribeDBClusterParametersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBClusterParameters", {})
     .n("RDSClient", "DescribeDBClusterParametersCommand")
-    .sc(schemas_0.DescribeDBClusterParameters$)
+    .sc(DescribeDBClusterParameters$)
     .build() {
 }
 
-class DescribeDBClustersCommand extends client.Command
+class DescribeDBClustersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBClusters", {})
     .n("RDSClient", "DescribeDBClustersCommand")
-    .sc(schemas_0.DescribeDBClusters$)
+    .sc(DescribeDBClusters$)
     .build() {
 }
 
-class DescribeDBClusterSnapshotAttributesCommand extends client.Command
+class DescribeDBClusterSnapshotAttributesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBClusterSnapshotAttributes", {})
     .n("RDSClient", "DescribeDBClusterSnapshotAttributesCommand")
-    .sc(schemas_0.DescribeDBClusterSnapshotAttributes$)
+    .sc(DescribeDBClusterSnapshotAttributes$)
     .build() {
 }
 
-class DescribeDBClusterSnapshotsCommand extends client.Command
+class DescribeDBClusterSnapshotsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBClusterSnapshots", {})
     .n("RDSClient", "DescribeDBClusterSnapshotsCommand")
-    .sc(schemas_0.DescribeDBClusterSnapshots$)
+    .sc(DescribeDBClusterSnapshots$)
     .build() {
 }
 
-class DescribeDBEngineVersionsCommand extends client.Command
+class DescribeDBEngineVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBEngineVersions", {})
     .n("RDSClient", "DescribeDBEngineVersionsCommand")
-    .sc(schemas_0.DescribeDBEngineVersions$)
+    .sc(DescribeDBEngineVersions$)
     .build() {
 }
 
-class DescribeDBInstanceAutomatedBackupsCommand extends client.Command
+class DescribeDBInstanceAutomatedBackupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBInstanceAutomatedBackups", {})
     .n("RDSClient", "DescribeDBInstanceAutomatedBackupsCommand")
-    .sc(schemas_0.DescribeDBInstanceAutomatedBackups$)
+    .sc(DescribeDBInstanceAutomatedBackups$)
     .build() {
 }
 
-class DescribeDBInstancesCommand extends client.Command
+class DescribeDBInstancesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBInstances", {})
     .n("RDSClient", "DescribeDBInstancesCommand")
-    .sc(schemas_0.DescribeDBInstances$)
+    .sc(DescribeDBInstances$)
     .build() {
 }
 
-class DescribeDBLogFilesCommand extends client.Command
+class DescribeDBLogFilesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBLogFiles", {})
     .n("RDSClient", "DescribeDBLogFilesCommand")
-    .sc(schemas_0.DescribeDBLogFiles$)
+    .sc(DescribeDBLogFiles$)
     .build() {
 }
 
-class DescribeDBMajorEngineVersionsCommand extends client.Command
+class DescribeDBMajorEngineVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBMajorEngineVersions", {})
     .n("RDSClient", "DescribeDBMajorEngineVersionsCommand")
-    .sc(schemas_0.DescribeDBMajorEngineVersions$)
+    .sc(DescribeDBMajorEngineVersions$)
     .build() {
 }
 
-class DescribeDBParameterGroupsCommand extends client.Command
+class DescribeDBParameterGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBParameterGroups", {})
     .n("RDSClient", "DescribeDBParameterGroupsCommand")
-    .sc(schemas_0.DescribeDBParameterGroups$)
+    .sc(DescribeDBParameterGroups$)
     .build() {
 }
 
-class DescribeDBParametersCommand extends client.Command
+class DescribeDBParametersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBParameters", {})
     .n("RDSClient", "DescribeDBParametersCommand")
-    .sc(schemas_0.DescribeDBParameters$)
+    .sc(DescribeDBParameters$)
     .build() {
 }
 
-class DescribeDBProxiesCommand extends client.Command
+class DescribeDBProxiesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBProxies", {})
     .n("RDSClient", "DescribeDBProxiesCommand")
-    .sc(schemas_0.DescribeDBProxies$)
+    .sc(DescribeDBProxies$)
     .build() {
 }
 
-class DescribeDBProxyEndpointsCommand extends client.Command
+class DescribeDBProxyEndpointsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBProxyEndpoints", {})
     .n("RDSClient", "DescribeDBProxyEndpointsCommand")
-    .sc(schemas_0.DescribeDBProxyEndpoints$)
+    .sc(DescribeDBProxyEndpoints$)
     .build() {
 }
 
-class DescribeDBProxyTargetGroupsCommand extends client.Command
+class DescribeDBProxyTargetGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBProxyTargetGroups", {})
     .n("RDSClient", "DescribeDBProxyTargetGroupsCommand")
-    .sc(schemas_0.DescribeDBProxyTargetGroups$)
+    .sc(DescribeDBProxyTargetGroups$)
     .build() {
 }
 
-class DescribeDBProxyTargetsCommand extends client.Command
+class DescribeDBProxyTargetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBProxyTargets", {})
     .n("RDSClient", "DescribeDBProxyTargetsCommand")
-    .sc(schemas_0.DescribeDBProxyTargets$)
+    .sc(DescribeDBProxyTargets$)
     .build() {
 }
 
-class DescribeDBRecommendationsCommand extends client.Command
+class DescribeDBRecommendationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBRecommendations", {})
     .n("RDSClient", "DescribeDBRecommendationsCommand")
-    .sc(schemas_0.DescribeDBRecommendations$)
+    .sc(DescribeDBRecommendations$)
     .build() {
 }
 
-class DescribeDBSecurityGroupsCommand extends client.Command
+class DescribeDBSecurityGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBSecurityGroups", {})
     .n("RDSClient", "DescribeDBSecurityGroupsCommand")
-    .sc(schemas_0.DescribeDBSecurityGroups$)
+    .sc(DescribeDBSecurityGroups$)
     .build() {
 }
 
-class DescribeDBShardGroupsCommand extends client.Command
+class DescribeDBShardGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBShardGroups", {})
     .n("RDSClient", "DescribeDBShardGroupsCommand")
-    .sc(schemas_0.DescribeDBShardGroups$)
+    .sc(DescribeDBShardGroups$)
     .build() {
 }
 
-class DescribeDBSnapshotAttributesCommand extends client.Command
+class DescribeDBSnapshotAttributesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBSnapshotAttributes", {})
     .n("RDSClient", "DescribeDBSnapshotAttributesCommand")
-    .sc(schemas_0.DescribeDBSnapshotAttributes$)
+    .sc(DescribeDBSnapshotAttributes$)
     .build() {
 }
 
-class DescribeDBSnapshotsCommand extends client.Command
+class DescribeDBSnapshotsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBSnapshots", {})
     .n("RDSClient", "DescribeDBSnapshotsCommand")
-    .sc(schemas_0.DescribeDBSnapshots$)
+    .sc(DescribeDBSnapshots$)
     .build() {
 }
 
-class DescribeDBSnapshotTenantDatabasesCommand extends client.Command
+class DescribeDBSnapshotTenantDatabasesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBSnapshotTenantDatabases", {})
     .n("RDSClient", "DescribeDBSnapshotTenantDatabasesCommand")
-    .sc(schemas_0.DescribeDBSnapshotTenantDatabases$)
+    .sc(DescribeDBSnapshotTenantDatabases$)
     .build() {
 }
 
-class DescribeDBSubnetGroupsCommand extends client.Command
+class DescribeDBSubnetGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeDBSubnetGroups", {})
     .n("RDSClient", "DescribeDBSubnetGroupsCommand")
-    .sc(schemas_0.DescribeDBSubnetGroups$)
+    .sc(DescribeDBSubnetGroups$)
     .build() {
 }
 
-class DescribeEngineDefaultClusterParametersCommand extends client.Command
+class DescribeEngineDefaultClusterParametersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeEngineDefaultClusterParameters", {})
     .n("RDSClient", "DescribeEngineDefaultClusterParametersCommand")
-    .sc(schemas_0.DescribeEngineDefaultClusterParameters$)
+    .sc(DescribeEngineDefaultClusterParameters$)
     .build() {
 }
 
-class DescribeEngineDefaultParametersCommand extends client.Command
+class DescribeEngineDefaultParametersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeEngineDefaultParameters", {})
     .n("RDSClient", "DescribeEngineDefaultParametersCommand")
-    .sc(schemas_0.DescribeEngineDefaultParameters$)
+    .sc(DescribeEngineDefaultParameters$)
     .build() {
 }
 
-class DescribeEventCategoriesCommand extends client.Command
+class DescribeEventCategoriesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeEventCategories", {})
     .n("RDSClient", "DescribeEventCategoriesCommand")
-    .sc(schemas_0.DescribeEventCategories$)
+    .sc(DescribeEventCategories$)
     .build() {
 }
 
-class DescribeEventsCommand extends client.Command
+class DescribeEventsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeEvents", {})
     .n("RDSClient", "DescribeEventsCommand")
-    .sc(schemas_0.DescribeEvents$)
+    .sc(DescribeEvents$)
     .build() {
 }
 
-class DescribeEventSubscriptionsCommand extends client.Command
+class DescribeEventSubscriptionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeEventSubscriptions", {})
     .n("RDSClient", "DescribeEventSubscriptionsCommand")
-    .sc(schemas_0.DescribeEventSubscriptions$)
+    .sc(DescribeEventSubscriptions$)
     .build() {
 }
 
-class DescribeExportTasksCommand extends client.Command
+class DescribeExportTasksCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeExportTasks", {})
     .n("RDSClient", "DescribeExportTasksCommand")
-    .sc(schemas_0.DescribeExportTasks$)
+    .sc(DescribeExportTasks$)
     .build() {
 }
 
-class DescribeGlobalClustersCommand extends client.Command
+class DescribeGlobalClustersCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeGlobalClusters", {})
     .n("RDSClient", "DescribeGlobalClustersCommand")
-    .sc(schemas_0.DescribeGlobalClusters$)
+    .sc(DescribeGlobalClusters$)
     .build() {
 }
 
-class DescribeIntegrationsCommand extends client.Command
+class DescribeIntegrationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeIntegrations", {})
     .n("RDSClient", "DescribeIntegrationsCommand")
-    .sc(schemas_0.DescribeIntegrations$)
+    .sc(DescribeIntegrations$)
     .build() {
 }
 
-class DescribeOptionGroupOptionsCommand extends client.Command
+class DescribeOptionGroupOptionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeOptionGroupOptions", {})
     .n("RDSClient", "DescribeOptionGroupOptionsCommand")
-    .sc(schemas_0.DescribeOptionGroupOptions$)
+    .sc(DescribeOptionGroupOptions$)
     .build() {
 }
 
-class DescribeOptionGroupsCommand extends client.Command
+class DescribeOptionGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeOptionGroups", {})
     .n("RDSClient", "DescribeOptionGroupsCommand")
-    .sc(schemas_0.DescribeOptionGroups$)
+    .sc(DescribeOptionGroups$)
     .build() {
 }
 
-class DescribeOrderableDBInstanceOptionsCommand extends client.Command
+class DescribeOrderableDBInstanceOptionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeOrderableDBInstanceOptions", {})
     .n("RDSClient", "DescribeOrderableDBInstanceOptionsCommand")
-    .sc(schemas_0.DescribeOrderableDBInstanceOptions$)
+    .sc(DescribeOrderableDBInstanceOptions$)
     .build() {
 }
 
-class DescribePendingMaintenanceActionsCommand extends client.Command
+class DescribePendingMaintenanceActionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribePendingMaintenanceActions", {})
     .n("RDSClient", "DescribePendingMaintenanceActionsCommand")
-    .sc(schemas_0.DescribePendingMaintenanceActions$)
+    .sc(DescribePendingMaintenanceActions$)
     .build() {
 }
 
-class DescribeReservedDBInstancesCommand extends client.Command
+class DescribeReservedDBInstancesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeReservedDBInstances", {})
     .n("RDSClient", "DescribeReservedDBInstancesCommand")
-    .sc(schemas_0.DescribeReservedDBInstances$)
+    .sc(DescribeReservedDBInstances$)
     .build() {
 }
 
-class DescribeReservedDBInstancesOfferingsCommand extends client.Command
+class DescribeReservedDBInstancesOfferingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeReservedDBInstancesOfferings", {})
     .n("RDSClient", "DescribeReservedDBInstancesOfferingsCommand")
-    .sc(schemas_0.DescribeReservedDBInstancesOfferings$)
+    .sc(DescribeReservedDBInstancesOfferings$)
     .build() {
 }
 
-class DescribeServerlessV2PlatformVersionsCommand extends client.Command
+class DescribeServerlessV2PlatformVersionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeServerlessV2PlatformVersions", {})
     .n("RDSClient", "DescribeServerlessV2PlatformVersionsCommand")
-    .sc(schemas_0.DescribeServerlessV2PlatformVersions$)
+    .sc(DescribeServerlessV2PlatformVersions$)
     .build() {
 }
 
-class DescribeSourceRegionsCommand extends client.Command
+class DescribeSourceRegionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeSourceRegions", {})
     .n("RDSClient", "DescribeSourceRegionsCommand")
-    .sc(schemas_0.DescribeSourceRegions$)
+    .sc(DescribeSourceRegions$)
     .build() {
 }
 
-class DescribeTenantDatabasesCommand extends client.Command
+class DescribeTenantDatabasesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeTenantDatabases", {})
     .n("RDSClient", "DescribeTenantDatabasesCommand")
-    .sc(schemas_0.DescribeTenantDatabases$)
+    .sc(DescribeTenantDatabases$)
     .build() {
 }
 
-class DescribeValidDBInstanceModificationsCommand extends client.Command
+class DescribeValidDBInstanceModificationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DescribeValidDBInstanceModifications", {})
     .n("RDSClient", "DescribeValidDBInstanceModificationsCommand")
-    .sc(schemas_0.DescribeValidDBInstanceModifications$)
+    .sc(DescribeValidDBInstanceModifications$)
     .build() {
 }
 
-class DisableHttpEndpointCommand extends client.Command
+class DisableHttpEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DisableHttpEndpoint", {})
     .n("RDSClient", "DisableHttpEndpointCommand")
-    .sc(schemas_0.DisableHttpEndpoint$)
+    .sc(DisableHttpEndpoint$)
     .build() {
 }
 
-class DownloadDBLogFilePortionCommand extends client.Command
+class DownloadDBLogFilePortionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "DownloadDBLogFilePortion", {})
     .n("RDSClient", "DownloadDBLogFilePortionCommand")
-    .sc(schemas_0.DownloadDBLogFilePortion$)
+    .sc(DownloadDBLogFilePortion$)
     .build() {
 }
 
-class EnableHttpEndpointCommand extends client.Command
+class EnableHttpEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "EnableHttpEndpoint", {})
     .n("RDSClient", "EnableHttpEndpointCommand")
-    .sc(schemas_0.EnableHttpEndpoint$)
+    .sc(EnableHttpEndpoint$)
     .build() {
 }
 
-class FailoverDBClusterCommand extends client.Command
+class FailoverDBClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "FailoverDBCluster", {})
     .n("RDSClient", "FailoverDBClusterCommand")
-    .sc(schemas_0.FailoverDBCluster$)
+    .sc(FailoverDBCluster$)
     .build() {
 }
 
-class FailoverGlobalClusterCommand extends client.Command
+class FailoverGlobalClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "FailoverGlobalCluster", {})
     .n("RDSClient", "FailoverGlobalClusterCommand")
-    .sc(schemas_0.FailoverGlobalCluster$)
+    .sc(FailoverGlobalCluster$)
     .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("AmazonRDSv19", "ListTagsForResource", {})
     .n("RDSClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class ModifyActivityStreamCommand extends client.Command
+class ModifyActivityStreamCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyActivityStream", {})
     .n("RDSClient", "ModifyActivityStreamCommand")
-    .sc(schemas_0.ModifyActivityStream$)
+    .sc(ModifyActivityStream$)
     .build() {
 }
 
-class ModifyCertificatesCommand extends client.Command
+class ModifyCertificatesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyCertificates", {})
     .n("RDSClient", "ModifyCertificatesCommand")
-    .sc(schemas_0.ModifyCertificates$)
+    .sc(ModifyCertificates$)
     .build() {
 }
 
-class ModifyCurrentDBClusterCapacityCommand extends client.Command
+class ModifyCurrentDBClusterCapacityCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyCurrentDBClusterCapacity", {})
     .n("RDSClient", "ModifyCurrentDBClusterCapacityCommand")
-    .sc(schemas_0.ModifyCurrentDBClusterCapacity$)
+    .sc(ModifyCurrentDBClusterCapacity$)
     .build() {
 }
 
-class ModifyCustomDBEngineVersionCommand extends client.Command
+class ModifyCustomDBEngineVersionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyCustomDBEngineVersion", {})
     .n("RDSClient", "ModifyCustomDBEngineVersionCommand")
-    .sc(schemas_0.ModifyCustomDBEngineVersion$)
+    .sc(ModifyCustomDBEngineVersion$)
     .build() {
 }
 
-class ModifyDBClusterCommand extends client.Command
+class ModifyDBClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBCluster", {})
     .n("RDSClient", "ModifyDBClusterCommand")
-    .sc(schemas_0.ModifyDBCluster$)
+    .sc(ModifyDBCluster$)
     .build() {
 }
 
-class ModifyDBClusterEndpointCommand extends client.Command
+class ModifyDBClusterEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBClusterEndpoint", {})
     .n("RDSClient", "ModifyDBClusterEndpointCommand")
-    .sc(schemas_0.ModifyDBClusterEndpoint$)
+    .sc(ModifyDBClusterEndpoint$)
     .build() {
 }
 
-class ModifyDBClusterParameterGroupCommand extends client.Command
+class ModifyDBClusterParameterGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBClusterParameterGroup", {})
     .n("RDSClient", "ModifyDBClusterParameterGroupCommand")
-    .sc(schemas_0.ModifyDBClusterParameterGroup$)
+    .sc(ModifyDBClusterParameterGroup$)
     .build() {
 }
 
-class ModifyDBClusterSnapshotAttributeCommand extends client.Command
+class ModifyDBClusterSnapshotAttributeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBClusterSnapshotAttribute", {})
     .n("RDSClient", "ModifyDBClusterSnapshotAttributeCommand")
-    .sc(schemas_0.ModifyDBClusterSnapshotAttribute$)
+    .sc(ModifyDBClusterSnapshotAttribute$)
     .build() {
 }
 
-class ModifyDBInstanceCommand extends client.Command
+class ModifyDBInstanceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBInstance", {})
     .n("RDSClient", "ModifyDBInstanceCommand")
-    .sc(schemas_0.ModifyDBInstance$)
+    .sc(ModifyDBInstance$)
     .build() {
 }
 
-class ModifyDBParameterGroupCommand extends client.Command
+class ModifyDBParameterGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBParameterGroup", {})
     .n("RDSClient", "ModifyDBParameterGroupCommand")
-    .sc(schemas_0.ModifyDBParameterGroup$)
+    .sc(ModifyDBParameterGroup$)
     .build() {
 }
 
-class ModifyDBProxyCommand extends client.Command
+class ModifyDBProxyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBProxy", {})
     .n("RDSClient", "ModifyDBProxyCommand")
-    .sc(schemas_0.ModifyDBProxy$)
+    .sc(ModifyDBProxy$)
     .build() {
 }
 
-class ModifyDBProxyEndpointCommand extends client.Command
+class ModifyDBProxyEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBProxyEndpoint", {})
     .n("RDSClient", "ModifyDBProxyEndpointCommand")
-    .sc(schemas_0.ModifyDBProxyEndpoint$)
+    .sc(ModifyDBProxyEndpoint$)
     .build() {
 }
 
-class ModifyDBProxyTargetGroupCommand extends client.Command
+class ModifyDBProxyTargetGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBProxyTargetGroup", {})
     .n("RDSClient", "ModifyDBProxyTargetGroupCommand")
-    .sc(schemas_0.ModifyDBProxyTargetGroup$)
+    .sc(ModifyDBProxyTargetGroup$)
     .build() {
 }
 
-class ModifyDBRecommendationCommand extends client.Command
+class ModifyDBRecommendationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBRecommendation", {})
     .n("RDSClient", "ModifyDBRecommendationCommand")
-    .sc(schemas_0.ModifyDBRecommendation$)
+    .sc(ModifyDBRecommendation$)
     .build() {
 }
 
-class ModifyDBShardGroupCommand extends client.Command
+class ModifyDBShardGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBShardGroup", {})
     .n("RDSClient", "ModifyDBShardGroupCommand")
-    .sc(schemas_0.ModifyDBShardGroup$)
+    .sc(ModifyDBShardGroup$)
     .build() {
 }
 
-class ModifyDBSnapshotAttributeCommand extends client.Command
+class ModifyDBSnapshotAttributeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBSnapshotAttribute", {})
     .n("RDSClient", "ModifyDBSnapshotAttributeCommand")
-    .sc(schemas_0.ModifyDBSnapshotAttribute$)
+    .sc(ModifyDBSnapshotAttribute$)
     .build() {
 }
 
-class ModifyDBSnapshotCommand extends client.Command
+class ModifyDBSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBSnapshot", {})
     .n("RDSClient", "ModifyDBSnapshotCommand")
-    .sc(schemas_0.ModifyDBSnapshot$)
+    .sc(ModifyDBSnapshot$)
     .build() {
 }
 
-class ModifyDBSubnetGroupCommand extends client.Command
+class ModifyDBSubnetGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyDBSubnetGroup", {})
     .n("RDSClient", "ModifyDBSubnetGroupCommand")
-    .sc(schemas_0.ModifyDBSubnetGroup$)
+    .sc(ModifyDBSubnetGroup$)
     .build() {
 }
 
-class ModifyEventSubscriptionCommand extends client.Command
+class ModifyEventSubscriptionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyEventSubscription", {})
     .n("RDSClient", "ModifyEventSubscriptionCommand")
-    .sc(schemas_0.ModifyEventSubscription$)
+    .sc(ModifyEventSubscription$)
     .build() {
 }
 
-class ModifyGlobalClusterCommand extends client.Command
+class ModifyGlobalClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyGlobalCluster", {})
     .n("RDSClient", "ModifyGlobalClusterCommand")
-    .sc(schemas_0.ModifyGlobalCluster$)
+    .sc(ModifyGlobalCluster$)
     .build() {
 }
 
-class ModifyIntegrationCommand extends client.Command
+class ModifyIntegrationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyIntegration", {})
     .n("RDSClient", "ModifyIntegrationCommand")
-    .sc(schemas_0.ModifyIntegration$)
+    .sc(ModifyIntegration$)
     .build() {
 }
 
-class ModifyOptionGroupCommand extends client.Command
+class ModifyOptionGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyOptionGroup", {})
     .n("RDSClient", "ModifyOptionGroupCommand")
-    .sc(schemas_0.ModifyOptionGroup$)
+    .sc(ModifyOptionGroup$)
     .build() {
 }
 
-class ModifyTenantDatabaseCommand extends client.Command
+class ModifyTenantDatabaseCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ModifyTenantDatabase", {})
     .n("RDSClient", "ModifyTenantDatabaseCommand")
-    .sc(schemas_0.ModifyTenantDatabase$)
+    .sc(ModifyTenantDatabase$)
     .build() {
 }
 
-class PromoteReadReplicaCommand extends client.Command
+class PromoteReadReplicaCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "PromoteReadReplica", {})
     .n("RDSClient", "PromoteReadReplicaCommand")
-    .sc(schemas_0.PromoteReadReplica$)
+    .sc(PromoteReadReplica$)
     .build() {
 }
 
-class PromoteReadReplicaDBClusterCommand extends client.Command
+class PromoteReadReplicaDBClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "PromoteReadReplicaDBCluster", {})
     .n("RDSClient", "PromoteReadReplicaDBClusterCommand")
-    .sc(schemas_0.PromoteReadReplicaDBCluster$)
+    .sc(PromoteReadReplicaDBCluster$)
     .build() {
 }
 
-class PurchaseReservedDBInstancesOfferingCommand extends client.Command
+class PurchaseReservedDBInstancesOfferingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "PurchaseReservedDBInstancesOffering", {})
     .n("RDSClient", "PurchaseReservedDBInstancesOfferingCommand")
-    .sc(schemas_0.PurchaseReservedDBInstancesOffering$)
+    .sc(PurchaseReservedDBInstancesOffering$)
     .build() {
 }
 
-class RebootDBClusterCommand extends client.Command
+class RebootDBClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RebootDBCluster", {})
     .n("RDSClient", "RebootDBClusterCommand")
-    .sc(schemas_0.RebootDBCluster$)
+    .sc(RebootDBCluster$)
     .build() {
 }
 
-class RebootDBInstanceCommand extends client.Command
+class RebootDBInstanceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RebootDBInstance", {})
     .n("RDSClient", "RebootDBInstanceCommand")
-    .sc(schemas_0.RebootDBInstance$)
+    .sc(RebootDBInstance$)
     .build() {
 }
 
-class RebootDBShardGroupCommand extends client.Command
+class RebootDBShardGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RebootDBShardGroup", {})
     .n("RDSClient", "RebootDBShardGroupCommand")
-    .sc(schemas_0.RebootDBShardGroup$)
+    .sc(RebootDBShardGroup$)
     .build() {
 }
 
-class RegisterDBProxyTargetsCommand extends client.Command
+class RegisterDBProxyTargetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RegisterDBProxyTargets", {})
     .n("RDSClient", "RegisterDBProxyTargetsCommand")
-    .sc(schemas_0.RegisterDBProxyTargets$)
+    .sc(RegisterDBProxyTargets$)
     .build() {
 }
 
-class RemoveFromGlobalClusterCommand extends client.Command
+class RemoveFromGlobalClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RemoveFromGlobalCluster", {})
     .n("RDSClient", "RemoveFromGlobalClusterCommand")
-    .sc(schemas_0.RemoveFromGlobalCluster$)
+    .sc(RemoveFromGlobalCluster$)
     .build() {
 }
 
-class RemoveRoleFromDBClusterCommand extends client.Command
+class RemoveRoleFromDBClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RemoveRoleFromDBCluster", {})
     .n("RDSClient", "RemoveRoleFromDBClusterCommand")
-    .sc(schemas_0.RemoveRoleFromDBCluster$)
+    .sc(RemoveRoleFromDBCluster$)
     .build() {
 }
 
-class RemoveRoleFromDBInstanceCommand extends client.Command
+class RemoveRoleFromDBInstanceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RemoveRoleFromDBInstance", {})
     .n("RDSClient", "RemoveRoleFromDBInstanceCommand")
-    .sc(schemas_0.RemoveRoleFromDBInstance$)
+    .sc(RemoveRoleFromDBInstance$)
     .build() {
 }
 
-class RemoveSourceIdentifierFromSubscriptionCommand extends client.Command
+class RemoveSourceIdentifierFromSubscriptionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RemoveSourceIdentifierFromSubscription", {})
     .n("RDSClient", "RemoveSourceIdentifierFromSubscriptionCommand")
-    .sc(schemas_0.RemoveSourceIdentifierFromSubscription$)
+    .sc(RemoveSourceIdentifierFromSubscription$)
     .build() {
 }
 
-class RemoveTagsFromResourceCommand extends client.Command
+class RemoveTagsFromResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RemoveTagsFromResource", {})
     .n("RDSClient", "RemoveTagsFromResourceCommand")
-    .sc(schemas_0.RemoveTagsFromResource$)
+    .sc(RemoveTagsFromResource$)
     .build() {
 }
 
-class ResetDBClusterParameterGroupCommand extends client.Command
+class ResetDBClusterParameterGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ResetDBClusterParameterGroup", {})
     .n("RDSClient", "ResetDBClusterParameterGroupCommand")
-    .sc(schemas_0.ResetDBClusterParameterGroup$)
+    .sc(ResetDBClusterParameterGroup$)
     .build() {
 }
 
-class ResetDBParameterGroupCommand extends client.Command
+class ResetDBParameterGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "ResetDBParameterGroup", {})
     .n("RDSClient", "ResetDBParameterGroupCommand")
-    .sc(schemas_0.ResetDBParameterGroup$)
+    .sc(ResetDBParameterGroup$)
     .build() {
 }
 
-class RestoreDBClusterFromS3Command extends client.Command
+class RestoreDBClusterFromS3Command extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RestoreDBClusterFromS3", {})
     .n("RDSClient", "RestoreDBClusterFromS3Command")
-    .sc(schemas_0.RestoreDBClusterFromS3$)
+    .sc(RestoreDBClusterFromS3$)
     .build() {
 }
 
-class RestoreDBClusterFromSnapshotCommand extends client.Command
+class RestoreDBClusterFromSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RestoreDBClusterFromSnapshot", {})
     .n("RDSClient", "RestoreDBClusterFromSnapshotCommand")
-    .sc(schemas_0.RestoreDBClusterFromSnapshot$)
+    .sc(RestoreDBClusterFromSnapshot$)
     .build() {
 }
 
-class RestoreDBClusterToPointInTimeCommand extends client.Command
+class RestoreDBClusterToPointInTimeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RestoreDBClusterToPointInTime", {})
     .n("RDSClient", "RestoreDBClusterToPointInTimeCommand")
-    .sc(schemas_0.RestoreDBClusterToPointInTime$)
+    .sc(RestoreDBClusterToPointInTime$)
     .build() {
 }
 
-class RestoreDBInstanceFromDBSnapshotCommand extends client.Command
+class RestoreDBInstanceFromDBSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RestoreDBInstanceFromDBSnapshot", {})
     .n("RDSClient", "RestoreDBInstanceFromDBSnapshotCommand")
-    .sc(schemas_0.RestoreDBInstanceFromDBSnapshot$)
+    .sc(RestoreDBInstanceFromDBSnapshot$)
     .build() {
 }
 
-class RestoreDBInstanceFromS3Command extends client.Command
+class RestoreDBInstanceFromS3Command extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RestoreDBInstanceFromS3", {})
     .n("RDSClient", "RestoreDBInstanceFromS3Command")
-    .sc(schemas_0.RestoreDBInstanceFromS3$)
+    .sc(RestoreDBInstanceFromS3$)
     .build() {
 }
 
-class RestoreDBInstanceToPointInTimeCommand extends client.Command
+class RestoreDBInstanceToPointInTimeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RestoreDBInstanceToPointInTime", {})
     .n("RDSClient", "RestoreDBInstanceToPointInTimeCommand")
-    .sc(schemas_0.RestoreDBInstanceToPointInTime$)
+    .sc(RestoreDBInstanceToPointInTime$)
     .build() {
 }
 
-class RevokeDBSecurityGroupIngressCommand extends client.Command
+class RevokeDBSecurityGroupIngressCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "RevokeDBSecurityGroupIngress", {})
     .n("RDSClient", "RevokeDBSecurityGroupIngressCommand")
-    .sc(schemas_0.RevokeDBSecurityGroupIngress$)
+    .sc(RevokeDBSecurityGroupIngress$)
     .build() {
 }
 
-class StartActivityStreamCommand extends client.Command
+class StartActivityStreamCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "StartActivityStream", {})
     .n("RDSClient", "StartActivityStreamCommand")
-    .sc(schemas_0.StartActivityStream$)
+    .sc(StartActivityStream$)
     .build() {
 }
 
-class StartDBClusterCommand extends client.Command
+class StartDBClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "StartDBCluster", {})
     .n("RDSClient", "StartDBClusterCommand")
-    .sc(schemas_0.StartDBCluster$)
+    .sc(StartDBCluster$)
     .build() {
 }
 
-class StartDBInstanceAutomatedBackupsReplicationCommand extends client.Command
+class StartDBInstanceAutomatedBackupsReplicationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-        middlewareSdkRds.getCrossRegionPresignedUrlPlugin(config),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+        getCrossRegionPresignedUrlPlugin(config),
     ];
 })
     .s("AmazonRDSv19", "StartDBInstanceAutomatedBackupsReplication", {})
     .n("RDSClient", "StartDBInstanceAutomatedBackupsReplicationCommand")
-    .sc(schemas_0.StartDBInstanceAutomatedBackupsReplication$)
+    .sc(StartDBInstanceAutomatedBackupsReplication$)
     .build() {
 }
 
-class StartDBInstanceCommand extends client.Command
+class StartDBInstanceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "StartDBInstance", {})
     .n("RDSClient", "StartDBInstanceCommand")
-    .sc(schemas_0.StartDBInstance$)
+    .sc(StartDBInstance$)
     .build() {
 }
 
-class StartExportTaskCommand extends client.Command
+class StartExportTaskCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "StartExportTask", {})
     .n("RDSClient", "StartExportTaskCommand")
-    .sc(schemas_0.StartExportTask$)
+    .sc(StartExportTask$)
     .build() {
 }
 
-class StopActivityStreamCommand extends client.Command
+class StopActivityStreamCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "StopActivityStream", {})
     .n("RDSClient", "StopActivityStreamCommand")
-    .sc(schemas_0.StopActivityStream$)
+    .sc(StopActivityStream$)
     .build() {
 }
 
-class StopDBClusterCommand extends client.Command
+class StopDBClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "StopDBCluster", {})
     .n("RDSClient", "StopDBClusterCommand")
-    .sc(schemas_0.StopDBCluster$)
+    .sc(StopDBCluster$)
     .build() {
 }
 
-class StopDBInstanceAutomatedBackupsReplicationCommand extends client.Command
+class StopDBInstanceAutomatedBackupsReplicationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "StopDBInstanceAutomatedBackupsReplication", {})
     .n("RDSClient", "StopDBInstanceAutomatedBackupsReplicationCommand")
-    .sc(schemas_0.StopDBInstanceAutomatedBackupsReplication$)
+    .sc(StopDBInstanceAutomatedBackupsReplication$)
     .build() {
 }
 
-class StopDBInstanceCommand extends client.Command
+class StopDBInstanceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "StopDBInstance", {})
     .n("RDSClient", "StopDBInstanceCommand")
-    .sc(schemas_0.StopDBInstance$)
+    .sc(StopDBInstance$)
     .build() {
 }
 
-class SwitchoverBlueGreenDeploymentCommand extends client.Command
+class SwitchoverBlueGreenDeploymentCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "SwitchoverBlueGreenDeployment", {})
     .n("RDSClient", "SwitchoverBlueGreenDeploymentCommand")
-    .sc(schemas_0.SwitchoverBlueGreenDeployment$)
+    .sc(SwitchoverBlueGreenDeployment$)
     .build() {
 }
 
-class SwitchoverGlobalClusterCommand extends client.Command
+class SwitchoverGlobalClusterCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "SwitchoverGlobalCluster", {})
     .n("RDSClient", "SwitchoverGlobalClusterCommand")
-    .sc(schemas_0.SwitchoverGlobalCluster$)
+    .sc(SwitchoverGlobalCluster$)
     .build() {
 }
 
-class SwitchoverReadReplicaCommand extends client.Command
+class SwitchoverReadReplicaCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonRDSv19", "SwitchoverReadReplica", {})
     .n("RDSClient", "SwitchoverReadReplicaCommand")
-    .sc(schemas_0.SwitchoverReadReplica$)
+    .sc(SwitchoverReadReplica$)
     .build() {
 }
 
-const paginateDescribeBlueGreenDeployments = core.createPaginator(RDSClient, DescribeBlueGreenDeploymentsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeBlueGreenDeployments = createPaginator(RDSClient, DescribeBlueGreenDeploymentsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeCertificates = core.createPaginator(RDSClient, DescribeCertificatesCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeCertificates = createPaginator(RDSClient, DescribeCertificatesCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBClusterAutomatedBackups = core.createPaginator(RDSClient, DescribeDBClusterAutomatedBackupsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBClusterAutomatedBackups = createPaginator(RDSClient, DescribeDBClusterAutomatedBackupsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBClusterBacktracks = core.createPaginator(RDSClient, DescribeDBClusterBacktracksCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBClusterBacktracks = createPaginator(RDSClient, DescribeDBClusterBacktracksCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBClusterEndpoints = core.createPaginator(RDSClient, DescribeDBClusterEndpointsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBClusterEndpoints = createPaginator(RDSClient, DescribeDBClusterEndpointsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBClusterParameterGroups = core.createPaginator(RDSClient, DescribeDBClusterParameterGroupsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBClusterParameterGroups = createPaginator(RDSClient, DescribeDBClusterParameterGroupsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBClusterParameters = core.createPaginator(RDSClient, DescribeDBClusterParametersCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBClusterParameters = createPaginator(RDSClient, DescribeDBClusterParametersCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBClusterSnapshots = core.createPaginator(RDSClient, DescribeDBClusterSnapshotsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBClusterSnapshots = createPaginator(RDSClient, DescribeDBClusterSnapshotsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBClusters = core.createPaginator(RDSClient, DescribeDBClustersCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBClusters = createPaginator(RDSClient, DescribeDBClustersCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBEngineVersions = core.createPaginator(RDSClient, DescribeDBEngineVersionsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBEngineVersions = createPaginator(RDSClient, DescribeDBEngineVersionsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBInstanceAutomatedBackups = core.createPaginator(RDSClient, DescribeDBInstanceAutomatedBackupsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBInstanceAutomatedBackups = createPaginator(RDSClient, DescribeDBInstanceAutomatedBackupsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBInstances = core.createPaginator(RDSClient, DescribeDBInstancesCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBInstances = createPaginator(RDSClient, DescribeDBInstancesCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBLogFiles = core.createPaginator(RDSClient, DescribeDBLogFilesCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBLogFiles = createPaginator(RDSClient, DescribeDBLogFilesCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBMajorEngineVersions = core.createPaginator(RDSClient, DescribeDBMajorEngineVersionsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBMajorEngineVersions = createPaginator(RDSClient, DescribeDBMajorEngineVersionsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBParameterGroups = core.createPaginator(RDSClient, DescribeDBParameterGroupsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBParameterGroups = createPaginator(RDSClient, DescribeDBParameterGroupsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBParameters = core.createPaginator(RDSClient, DescribeDBParametersCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBParameters = createPaginator(RDSClient, DescribeDBParametersCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBProxies = core.createPaginator(RDSClient, DescribeDBProxiesCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBProxies = createPaginator(RDSClient, DescribeDBProxiesCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBProxyEndpoints = core.createPaginator(RDSClient, DescribeDBProxyEndpointsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBProxyEndpoints = createPaginator(RDSClient, DescribeDBProxyEndpointsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBProxyTargetGroups = core.createPaginator(RDSClient, DescribeDBProxyTargetGroupsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBProxyTargetGroups = createPaginator(RDSClient, DescribeDBProxyTargetGroupsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBProxyTargets = core.createPaginator(RDSClient, DescribeDBProxyTargetsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBProxyTargets = createPaginator(RDSClient, DescribeDBProxyTargetsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBRecommendations = core.createPaginator(RDSClient, DescribeDBRecommendationsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBRecommendations = createPaginator(RDSClient, DescribeDBRecommendationsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBSecurityGroups = core.createPaginator(RDSClient, DescribeDBSecurityGroupsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBSecurityGroups = createPaginator(RDSClient, DescribeDBSecurityGroupsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBSnapshots = core.createPaginator(RDSClient, DescribeDBSnapshotsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBSnapshots = createPaginator(RDSClient, DescribeDBSnapshotsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBSnapshotTenantDatabases = core.createPaginator(RDSClient, DescribeDBSnapshotTenantDatabasesCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBSnapshotTenantDatabases = createPaginator(RDSClient, DescribeDBSnapshotTenantDatabasesCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeDBSubnetGroups = core.createPaginator(RDSClient, DescribeDBSubnetGroupsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeDBSubnetGroups = createPaginator(RDSClient, DescribeDBSubnetGroupsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeEngineDefaultClusterParameters = core.createPaginator(RDSClient, DescribeEngineDefaultClusterParametersCommand, "Marker", "EngineDefaults.Marker", "MaxRecords");
+const paginateDescribeEngineDefaultClusterParameters = createPaginator(RDSClient, DescribeEngineDefaultClusterParametersCommand, "Marker", "EngineDefaults.Marker", "MaxRecords");
 
-const paginateDescribeEngineDefaultParameters = core.createPaginator(RDSClient, DescribeEngineDefaultParametersCommand, "Marker", "EngineDefaults.Marker", "MaxRecords");
+const paginateDescribeEngineDefaultParameters = createPaginator(RDSClient, DescribeEngineDefaultParametersCommand, "Marker", "EngineDefaults.Marker", "MaxRecords");
 
-const paginateDescribeEvents = core.createPaginator(RDSClient, DescribeEventsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeEvents = createPaginator(RDSClient, DescribeEventsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeEventSubscriptions = core.createPaginator(RDSClient, DescribeEventSubscriptionsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeEventSubscriptions = createPaginator(RDSClient, DescribeEventSubscriptionsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeExportTasks = core.createPaginator(RDSClient, DescribeExportTasksCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeExportTasks = createPaginator(RDSClient, DescribeExportTasksCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeGlobalClusters = core.createPaginator(RDSClient, DescribeGlobalClustersCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeGlobalClusters = createPaginator(RDSClient, DescribeGlobalClustersCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeIntegrations = core.createPaginator(RDSClient, DescribeIntegrationsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeIntegrations = createPaginator(RDSClient, DescribeIntegrationsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeOptionGroupOptions = core.createPaginator(RDSClient, DescribeOptionGroupOptionsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeOptionGroupOptions = createPaginator(RDSClient, DescribeOptionGroupOptionsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeOptionGroups = core.createPaginator(RDSClient, DescribeOptionGroupsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeOptionGroups = createPaginator(RDSClient, DescribeOptionGroupsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeOrderableDBInstanceOptions = core.createPaginator(RDSClient, DescribeOrderableDBInstanceOptionsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeOrderableDBInstanceOptions = createPaginator(RDSClient, DescribeOrderableDBInstanceOptionsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribePendingMaintenanceActions = core.createPaginator(RDSClient, DescribePendingMaintenanceActionsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribePendingMaintenanceActions = createPaginator(RDSClient, DescribePendingMaintenanceActionsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeReservedDBInstancesOfferings = core.createPaginator(RDSClient, DescribeReservedDBInstancesOfferingsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeReservedDBInstancesOfferings = createPaginator(RDSClient, DescribeReservedDBInstancesOfferingsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeReservedDBInstances = core.createPaginator(RDSClient, DescribeReservedDBInstancesCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeReservedDBInstances = createPaginator(RDSClient, DescribeReservedDBInstancesCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeServerlessV2PlatformVersions = core.createPaginator(RDSClient, DescribeServerlessV2PlatformVersionsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeServerlessV2PlatformVersions = createPaginator(RDSClient, DescribeServerlessV2PlatformVersionsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeSourceRegions = core.createPaginator(RDSClient, DescribeSourceRegionsCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeSourceRegions = createPaginator(RDSClient, DescribeSourceRegionsCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDescribeTenantDatabases = core.createPaginator(RDSClient, DescribeTenantDatabasesCommand, "Marker", "Marker", "MaxRecords");
+const paginateDescribeTenantDatabases = createPaginator(RDSClient, DescribeTenantDatabasesCommand, "Marker", "Marker", "MaxRecords");
 
-const paginateDownloadDBLogFilePortion = core.createPaginator(RDSClient, DownloadDBLogFilePortionCommand, "Marker", "Marker", "NumberOfLines");
+const paginateDownloadDBLogFilePortion = createPaginator(RDSClient, DownloadDBLogFilePortionCommand, "Marker", "Marker", "NumberOfLines");
 
-const checkState$9 = async (client$1, input) => {
+const checkState$9 = async (client, input) => {
     let reason;
     try {
-        let result = await client$1.send(new DescribeDBClustersCommand(input));
+        let result = await client.send(new DescribeDBClustersCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -2194,7 +2197,7 @@ const checkState$9 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "available");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2208,7 +2211,7 @@ const checkState$9 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "deleted") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2223,7 +2226,7 @@ const checkState$9 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "deleting") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2238,7 +2241,7 @@ const checkState$9 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "failed") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2253,7 +2256,7 @@ const checkState$9 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "incompatible-restore") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2268,7 +2271,7 @@ const checkState$9 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "incompatible-parameters") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2277,29 +2280,29 @@ const checkState$9 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDBClusterAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$9);
 };
 const waitUntilDBClusterAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    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 DescribeDBClustersCommand(input));
+        let result = await client.send(new DescribeDBClustersCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return (result.DBClusters.length == 0);
             };
             if (returnComparator() == true) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2313,7 +2316,7 @@ const checkState$8 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "creating") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2328,7 +2331,7 @@ const checkState$8 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "modifying") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2343,7 +2346,7 @@ const checkState$8 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "rebooting") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2358,7 +2361,7 @@ const checkState$8 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "resetting-master-credentials") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2367,25 +2370,25 @@ const checkState$8 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "DBClusterNotFoundFault") {
-            return { state: client.WaiterState.SUCCESS, reason };
+            return { state: WaiterState.SUCCESS, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDBClusterDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
 };
 const waitUntilDBClusterDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    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 DescribeDBClusterSnapshotsCommand(input));
+        let result = await client.send(new DescribeDBClusterSnapshotsCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -2400,7 +2403,7 @@ const checkState$7 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "available");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2414,7 +2417,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "deleted") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2429,7 +2432,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "deleting") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2444,7 +2447,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "failed") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2459,7 +2462,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "incompatible-restore") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2474,7 +2477,7 @@ const checkState$7 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "incompatible-parameters") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2483,29 +2486,29 @@ const checkState$7 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDBClusterSnapshotAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
 };
 const waitUntilDBClusterSnapshotAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    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 DescribeDBClusterSnapshotsCommand(input));
+        let result = await client.send(new DescribeDBClusterSnapshotsCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return (result.DBClusterSnapshots.length == 0);
             };
             if (returnComparator() == true) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2519,7 +2522,7 @@ const checkState$6 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "creating") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2534,7 +2537,7 @@ const checkState$6 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "modifying") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2549,7 +2552,7 @@ const checkState$6 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "rebooting") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2564,7 +2567,7 @@ const checkState$6 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "resetting-master-credentials") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2573,25 +2576,25 @@ const checkState$6 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "DBClusterSnapshotNotFoundFault") {
-            return { state: client.WaiterState.SUCCESS, reason };
+            return { state: WaiterState.SUCCESS, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDBClusterSnapshotDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$6);
 };
 const waitUntilDBClusterSnapshotDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    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 DescribeDBInstancesCommand(input));
+        let result = await client.send(new DescribeDBInstancesCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -2606,7 +2609,7 @@ const checkState$5 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "available");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2620,7 +2623,7 @@ const checkState$5 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "deleted") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2635,7 +2638,7 @@ const checkState$5 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "deleting") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2650,7 +2653,7 @@ const checkState$5 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "failed") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2665,7 +2668,7 @@ const checkState$5 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "incompatible-restore") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2680,7 +2683,7 @@ const checkState$5 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "incompatible-parameters") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2689,29 +2692,29 @@ const checkState$5 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDBInstanceAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
 };
 const waitUntilDBInstanceAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    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 DescribeDBInstancesCommand(input));
+        let result = await client.send(new DescribeDBInstancesCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return (result.DBInstances.length == 0);
             };
             if (returnComparator() == true) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2725,7 +2728,7 @@ const checkState$4 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "creating") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2740,7 +2743,7 @@ const checkState$4 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "modifying") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2755,7 +2758,7 @@ const checkState$4 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "rebooting") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2770,7 +2773,7 @@ const checkState$4 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "resetting-master-credentials") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2779,25 +2782,25 @@ const checkState$4 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "DBInstanceNotFoundFault") {
-            return { state: client.WaiterState.SUCCESS, reason };
+            return { state: WaiterState.SUCCESS, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDBInstanceDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
 };
 const waitUntilDBInstanceDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    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 DescribeDBSnapshotsCommand(input));
+        let result = await client.send(new DescribeDBSnapshotsCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -2812,7 +2815,7 @@ const checkState$3 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "available");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2826,7 +2829,7 @@ const checkState$3 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "deleted") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2841,7 +2844,7 @@ const checkState$3 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "deleting") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2856,7 +2859,7 @@ const checkState$3 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "failed") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2871,7 +2874,7 @@ const checkState$3 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "incompatible-restore") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2886,7 +2889,7 @@ const checkState$3 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "incompatible-parameters") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2895,29 +2898,29 @@ const checkState$3 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDBSnapshotAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
 const waitUntilDBSnapshotAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    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 DescribeDBSnapshotsCommand(input));
+        let result = await client.send(new DescribeDBSnapshotsCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return (result.DBSnapshots.length == 0);
             };
             if (returnComparator() == true) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -2931,7 +2934,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "creating") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2946,7 +2949,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "modifying") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2961,7 +2964,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "rebooting") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2976,7 +2979,7 @@ const checkState$2 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "resetting-master-credentials") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -2985,25 +2988,25 @@ const checkState$2 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "DBSnapshotNotFoundFault") {
-            return { state: client.WaiterState.SUCCESS, reason };
+            return { state: WaiterState.SUCCESS, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForDBSnapshotDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilDBSnapshotDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    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 DescribeTenantDatabasesCommand(input));
+        let result = await client.send(new DescribeTenantDatabasesCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
@@ -3018,7 +3021,7 @@ const checkState$1 = async (client$1, input) => {
                 allStringEq_5 = allStringEq_5 && (element_4 == "available");
             }
             if (allStringEq_5) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -3032,7 +3035,7 @@ const checkState$1 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "deleted") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -3047,7 +3050,7 @@ const checkState$1 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "incompatible-parameters") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -3062,7 +3065,7 @@ const checkState$1 = async (client$1, input) => {
             };
             for (let anyStringEq_4 of returnComparator()) {
                 if (anyStringEq_4 == "incompatible-restore") {
-                    return { state: client.WaiterState.FAILURE, reason };
+                    return { state: WaiterState.FAILURE, reason };
                 }
             }
         }
@@ -3071,29 +3074,29 @@ const checkState$1 = async (client$1, input) => {
     catch (exception) {
         reason = exception;
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForTenantDatabaseAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilTenantDatabaseAvailable = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    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 DescribeTenantDatabasesCommand(input));
+        let result = await client.send(new DescribeTenantDatabasesCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return (result.TenantDatabases.length == 0);
             };
             if (returnComparator() == true) {
-                return { state: client.WaiterState.SUCCESS, reason };
+                return { state: WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -3101,19 +3104,19 @@ const checkState = async (client$1, input) => {
     catch (exception) {
         reason = exception;
         if (exception.name === "DBInstanceNotFoundFault") {
-            return { state: client.WaiterState.SUCCESS, reason };
+            return { state: WaiterState.SUCCESS, reason };
         }
     }
-    return { state: client.WaiterState.RETRY, reason };
+    return { state: WaiterState.RETRY, reason };
 };
 const waitForTenantDatabaseDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    return client.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
 const waitUntilTenantDatabaseDeleted = async (params, input) => {
     const serviceDefaults = { minDelay: 30, maxDelay: 1800 };
-    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 = {
@@ -3340,7 +3343,7 @@ const waiters = {
 };
 class RDS extends RDSClient {
 }
-client.createAggregatedClient(commands, RDS, { paginators, waiters });
+createAggregatedClient(commands, RDS, { paginators, waiters });
 
 const ActivityStreamMode = {
     async: "async",
@@ -3545,9 +3548,6 @@ const CustomEngineVersionStatus = {
     inactive_except_restore: "inactive-except-restore",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.RDSServiceException = RDSServiceException.RDSServiceException;
 exports.ActivityStreamMode = ActivityStreamMode;
 exports.ActivityStreamPolicyStatus = ActivityStreamPolicyStatus;
 exports.ActivityStreamStatus = ActivityStreamStatus;
@@ -3812,23 +3812,3 @@ exports.waitUntilDBSnapshotAvailable = waitUntilDBSnapshotAvailable;
 exports.waitUntilDBSnapshotDeleted = waitUntilDBSnapshotDeleted;
 exports.waitUntilTenantDatabaseAvailable = waitUntilTenantDatabaseAvailable;
 exports.waitUntilTenantDatabaseDeleted = waitUntilTenantDatabaseDeleted;
-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];
-});