@aws-sdk/client-redshift-serverless 3.1067.0 → 3.1069.0

package/dist-cjs/index.js

@@ -1,18 +1,21 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var RedshiftServerlessServiceException = require('./models/RedshiftServerlessServiceException');
+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, 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, defaultRedshiftServerlessHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { ConvertRecoveryPointToSnapshot$, CreateCustomDomainAssociation$, CreateEndpointAccess$, CreateNamespace$, CreateReservation$, CreateScheduledAction$, CreateSnapshot$, CreateSnapshotCopyConfiguration$, CreateUsageLimit$, CreateWorkgroup$, DeleteCustomDomainAssociation$, DeleteEndpointAccess$, DeleteNamespace$, DeleteResourcePolicy$, DeleteScheduledAction$, DeleteSnapshot$, DeleteSnapshotCopyConfiguration$, DeleteUsageLimit$, DeleteWorkgroup$, GetCredentials$, GetCustomDomainAssociation$, GetEndpointAccess$, GetIdentityCenterAuthToken$, GetNamespace$, GetRecoveryPoint$, GetReservation$, GetReservationOffering$, GetResourcePolicy$, GetScheduledAction$, GetSnapshot$, GetTableRestoreStatus$, GetTrack$, GetUsageLimit$, GetWorkgroup$, ListCustomDomainAssociations$, ListEndpointAccess$, ListManagedWorkgroups$, ListNamespaces$, ListRecoveryPoints$, ListReservationOfferings$, ListReservations$, ListScheduledActions$, ListSnapshotCopyConfigurations$, ListSnapshots$, ListTableRestoreStatus$, ListTagsForResource$, ListTracks$, ListUsageLimits$, ListWorkgroups$, PutResourcePolicy$, RestoreFromRecoveryPoint$, RestoreFromSnapshot$, RestoreTableFromRecoveryPoint$, RestoreTableFromSnapshot$, TagResource$, UntagResource$, UpdateCustomDomainAssociation$, UpdateEndpointAccess$, UpdateLakehouseConfiguration$, UpdateNamespace$, UpdateScheduledAction$, UpdateSnapshot$, UpdateSnapshotCopyConfiguration$, UpdateUsageLimit$, UpdateWorkgroup$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { RedshiftServerlessServiceException } = require("./models/RedshiftServerlessServiceException");
+exports.RedshiftServerlessServiceException = RedshiftServerlessServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,853 +71,853 @@ 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 RedshiftServerlessClient extends client.Client {
+class RedshiftServerlessClient 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.defaultRedshiftServerlessHttpAuthSchemeParametersProvider,
-            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: defaultRedshiftServerlessHttpAuthSchemeParametersProvider,
+            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 ConvertRecoveryPointToSnapshotCommand extends client.Command
+class ConvertRecoveryPointToSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ConvertRecoveryPointToSnapshot", {})
     .n("RedshiftServerlessClient", "ConvertRecoveryPointToSnapshotCommand")
-    .sc(schemas_0.ConvertRecoveryPointToSnapshot$)
+    .sc(ConvertRecoveryPointToSnapshot$)
     .build() {
 }
 
-class CreateCustomDomainAssociationCommand extends client.Command
+class CreateCustomDomainAssociationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "CreateCustomDomainAssociation", {})
     .n("RedshiftServerlessClient", "CreateCustomDomainAssociationCommand")
-    .sc(schemas_0.CreateCustomDomainAssociation$)
+    .sc(CreateCustomDomainAssociation$)
     .build() {
 }
 
-class CreateEndpointAccessCommand extends client.Command
+class CreateEndpointAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "CreateEndpointAccess", {})
     .n("RedshiftServerlessClient", "CreateEndpointAccessCommand")
-    .sc(schemas_0.CreateEndpointAccess$)
+    .sc(CreateEndpointAccess$)
     .build() {
 }
 
-class CreateNamespaceCommand extends client.Command
+class CreateNamespaceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "CreateNamespace", {})
     .n("RedshiftServerlessClient", "CreateNamespaceCommand")
-    .sc(schemas_0.CreateNamespace$)
+    .sc(CreateNamespace$)
     .build() {
 }
 
-class CreateReservationCommand extends client.Command
+class CreateReservationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "CreateReservation", {})
     .n("RedshiftServerlessClient", "CreateReservationCommand")
-    .sc(schemas_0.CreateReservation$)
+    .sc(CreateReservation$)
     .build() {
 }
 
-class CreateScheduledActionCommand extends client.Command
+class CreateScheduledActionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "CreateScheduledAction", {})
     .n("RedshiftServerlessClient", "CreateScheduledActionCommand")
-    .sc(schemas_0.CreateScheduledAction$)
+    .sc(CreateScheduledAction$)
     .build() {
 }
 
-class CreateSnapshotCommand extends client.Command
+class CreateSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "CreateSnapshot", {})
     .n("RedshiftServerlessClient", "CreateSnapshotCommand")
-    .sc(schemas_0.CreateSnapshot$)
+    .sc(CreateSnapshot$)
     .build() {
 }
 
-class CreateSnapshotCopyConfigurationCommand extends client.Command
+class CreateSnapshotCopyConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "CreateSnapshotCopyConfiguration", {})
     .n("RedshiftServerlessClient", "CreateSnapshotCopyConfigurationCommand")
-    .sc(schemas_0.CreateSnapshotCopyConfiguration$)
+    .sc(CreateSnapshotCopyConfiguration$)
     .build() {
 }
 
-class CreateUsageLimitCommand extends client.Command
+class CreateUsageLimitCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "CreateUsageLimit", {})
     .n("RedshiftServerlessClient", "CreateUsageLimitCommand")
-    .sc(schemas_0.CreateUsageLimit$)
+    .sc(CreateUsageLimit$)
     .build() {
 }
 
-class CreateWorkgroupCommand extends client.Command
+class CreateWorkgroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "CreateWorkgroup", {})
     .n("RedshiftServerlessClient", "CreateWorkgroupCommand")
-    .sc(schemas_0.CreateWorkgroup$)
+    .sc(CreateWorkgroup$)
     .build() {
 }
 
-class DeleteCustomDomainAssociationCommand extends client.Command
+class DeleteCustomDomainAssociationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "DeleteCustomDomainAssociation", {})
     .n("RedshiftServerlessClient", "DeleteCustomDomainAssociationCommand")
-    .sc(schemas_0.DeleteCustomDomainAssociation$)
+    .sc(DeleteCustomDomainAssociation$)
     .build() {
 }
 
-class DeleteEndpointAccessCommand extends client.Command
+class DeleteEndpointAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "DeleteEndpointAccess", {})
     .n("RedshiftServerlessClient", "DeleteEndpointAccessCommand")
-    .sc(schemas_0.DeleteEndpointAccess$)
+    .sc(DeleteEndpointAccess$)
     .build() {
 }
 
-class DeleteNamespaceCommand extends client.Command
+class DeleteNamespaceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "DeleteNamespace", {})
     .n("RedshiftServerlessClient", "DeleteNamespaceCommand")
-    .sc(schemas_0.DeleteNamespace$)
+    .sc(DeleteNamespace$)
     .build() {
 }
 
-class DeleteResourcePolicyCommand extends client.Command
+class DeleteResourcePolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "DeleteResourcePolicy", {})
     .n("RedshiftServerlessClient", "DeleteResourcePolicyCommand")
-    .sc(schemas_0.DeleteResourcePolicy$)
+    .sc(DeleteResourcePolicy$)
     .build() {
 }
 
-class DeleteScheduledActionCommand extends client.Command
+class DeleteScheduledActionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "DeleteScheduledAction", {})
     .n("RedshiftServerlessClient", "DeleteScheduledActionCommand")
-    .sc(schemas_0.DeleteScheduledAction$)
+    .sc(DeleteScheduledAction$)
     .build() {
 }
 
-class DeleteSnapshotCommand extends client.Command
+class DeleteSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "DeleteSnapshot", {})
     .n("RedshiftServerlessClient", "DeleteSnapshotCommand")
-    .sc(schemas_0.DeleteSnapshot$)
+    .sc(DeleteSnapshot$)
     .build() {
 }
 
-class DeleteSnapshotCopyConfigurationCommand extends client.Command
+class DeleteSnapshotCopyConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "DeleteSnapshotCopyConfiguration", {})
     .n("RedshiftServerlessClient", "DeleteSnapshotCopyConfigurationCommand")
-    .sc(schemas_0.DeleteSnapshotCopyConfiguration$)
+    .sc(DeleteSnapshotCopyConfiguration$)
     .build() {
 }
 
-class DeleteUsageLimitCommand extends client.Command
+class DeleteUsageLimitCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "DeleteUsageLimit", {})
     .n("RedshiftServerlessClient", "DeleteUsageLimitCommand")
-    .sc(schemas_0.DeleteUsageLimit$)
+    .sc(DeleteUsageLimit$)
     .build() {
 }
 
-class DeleteWorkgroupCommand extends client.Command
+class DeleteWorkgroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "DeleteWorkgroup", {})
     .n("RedshiftServerlessClient", "DeleteWorkgroupCommand")
-    .sc(schemas_0.DeleteWorkgroup$)
+    .sc(DeleteWorkgroup$)
     .build() {
 }
 
-class GetCredentialsCommand extends client.Command
+class GetCredentialsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetCredentials", {})
     .n("RedshiftServerlessClient", "GetCredentialsCommand")
-    .sc(schemas_0.GetCredentials$)
+    .sc(GetCredentials$)
     .build() {
 }
 
-class GetCustomDomainAssociationCommand extends client.Command
+class GetCustomDomainAssociationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetCustomDomainAssociation", {})
     .n("RedshiftServerlessClient", "GetCustomDomainAssociationCommand")
-    .sc(schemas_0.GetCustomDomainAssociation$)
+    .sc(GetCustomDomainAssociation$)
     .build() {
 }
 
-class GetEndpointAccessCommand extends client.Command
+class GetEndpointAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetEndpointAccess", {})
     .n("RedshiftServerlessClient", "GetEndpointAccessCommand")
-    .sc(schemas_0.GetEndpointAccess$)
+    .sc(GetEndpointAccess$)
     .build() {
 }
 
-class GetIdentityCenterAuthTokenCommand extends client.Command
+class GetIdentityCenterAuthTokenCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetIdentityCenterAuthToken", {})
     .n("RedshiftServerlessClient", "GetIdentityCenterAuthTokenCommand")
-    .sc(schemas_0.GetIdentityCenterAuthToken$)
+    .sc(GetIdentityCenterAuthToken$)
     .build() {
 }
 
-class GetNamespaceCommand extends client.Command
+class GetNamespaceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetNamespace", {})
     .n("RedshiftServerlessClient", "GetNamespaceCommand")
-    .sc(schemas_0.GetNamespace$)
+    .sc(GetNamespace$)
     .build() {
 }
 
-class GetRecoveryPointCommand extends client.Command
+class GetRecoveryPointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetRecoveryPoint", {})
     .n("RedshiftServerlessClient", "GetRecoveryPointCommand")
-    .sc(schemas_0.GetRecoveryPoint$)
+    .sc(GetRecoveryPoint$)
     .build() {
 }
 
-class GetReservationCommand extends client.Command
+class GetReservationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetReservation", {})
     .n("RedshiftServerlessClient", "GetReservationCommand")
-    .sc(schemas_0.GetReservation$)
+    .sc(GetReservation$)
     .build() {
 }
 
-class GetReservationOfferingCommand extends client.Command
+class GetReservationOfferingCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetReservationOffering", {})
     .n("RedshiftServerlessClient", "GetReservationOfferingCommand")
-    .sc(schemas_0.GetReservationOffering$)
+    .sc(GetReservationOffering$)
     .build() {
 }
 
-class GetResourcePolicyCommand extends client.Command
+class GetResourcePolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetResourcePolicy", {})
     .n("RedshiftServerlessClient", "GetResourcePolicyCommand")
-    .sc(schemas_0.GetResourcePolicy$)
+    .sc(GetResourcePolicy$)
     .build() {
 }
 
-class GetScheduledActionCommand extends client.Command
+class GetScheduledActionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetScheduledAction", {})
     .n("RedshiftServerlessClient", "GetScheduledActionCommand")
-    .sc(schemas_0.GetScheduledAction$)
+    .sc(GetScheduledAction$)
     .build() {
 }
 
-class GetSnapshotCommand extends client.Command
+class GetSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetSnapshot", {})
     .n("RedshiftServerlessClient", "GetSnapshotCommand")
-    .sc(schemas_0.GetSnapshot$)
+    .sc(GetSnapshot$)
     .build() {
 }
 
-class GetTableRestoreStatusCommand extends client.Command
+class GetTableRestoreStatusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetTableRestoreStatus", {})
     .n("RedshiftServerlessClient", "GetTableRestoreStatusCommand")
-    .sc(schemas_0.GetTableRestoreStatus$)
+    .sc(GetTableRestoreStatus$)
     .build() {
 }
 
-class GetTrackCommand extends client.Command
+class GetTrackCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetTrack", {})
     .n("RedshiftServerlessClient", "GetTrackCommand")
-    .sc(schemas_0.GetTrack$)
+    .sc(GetTrack$)
     .build() {
 }
 
-class GetUsageLimitCommand extends client.Command
+class GetUsageLimitCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetUsageLimit", {})
     .n("RedshiftServerlessClient", "GetUsageLimitCommand")
-    .sc(schemas_0.GetUsageLimit$)
+    .sc(GetUsageLimit$)
     .build() {
 }
 
-class GetWorkgroupCommand extends client.Command
+class GetWorkgroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "GetWorkgroup", {})
     .n("RedshiftServerlessClient", "GetWorkgroupCommand")
-    .sc(schemas_0.GetWorkgroup$)
+    .sc(GetWorkgroup$)
     .build() {
 }
 
-class ListCustomDomainAssociationsCommand extends client.Command
+class ListCustomDomainAssociationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListCustomDomainAssociations", {})
     .n("RedshiftServerlessClient", "ListCustomDomainAssociationsCommand")
-    .sc(schemas_0.ListCustomDomainAssociations$)
+    .sc(ListCustomDomainAssociations$)
     .build() {
 }
 
-class ListEndpointAccessCommand extends client.Command
+class ListEndpointAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListEndpointAccess", {})
     .n("RedshiftServerlessClient", "ListEndpointAccessCommand")
-    .sc(schemas_0.ListEndpointAccess$)
+    .sc(ListEndpointAccess$)
     .build() {
 }
 
-class ListManagedWorkgroupsCommand extends client.Command
+class ListManagedWorkgroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListManagedWorkgroups", {})
     .n("RedshiftServerlessClient", "ListManagedWorkgroupsCommand")
-    .sc(schemas_0.ListManagedWorkgroups$)
+    .sc(ListManagedWorkgroups$)
     .build() {
 }
 
-class ListNamespacesCommand extends client.Command
+class ListNamespacesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListNamespaces", {})
     .n("RedshiftServerlessClient", "ListNamespacesCommand")
-    .sc(schemas_0.ListNamespaces$)
+    .sc(ListNamespaces$)
     .build() {
 }
 
-class ListRecoveryPointsCommand extends client.Command
+class ListRecoveryPointsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListRecoveryPoints", {})
     .n("RedshiftServerlessClient", "ListRecoveryPointsCommand")
-    .sc(schemas_0.ListRecoveryPoints$)
+    .sc(ListRecoveryPoints$)
     .build() {
 }
 
-class ListReservationOfferingsCommand extends client.Command
+class ListReservationOfferingsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListReservationOfferings", {})
     .n("RedshiftServerlessClient", "ListReservationOfferingsCommand")
-    .sc(schemas_0.ListReservationOfferings$)
+    .sc(ListReservationOfferings$)
     .build() {
 }
 
-class ListReservationsCommand extends client.Command
+class ListReservationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListReservations", {})
     .n("RedshiftServerlessClient", "ListReservationsCommand")
-    .sc(schemas_0.ListReservations$)
+    .sc(ListReservations$)
     .build() {
 }
 
-class ListScheduledActionsCommand extends client.Command
+class ListScheduledActionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListScheduledActions", {})
     .n("RedshiftServerlessClient", "ListScheduledActionsCommand")
-    .sc(schemas_0.ListScheduledActions$)
+    .sc(ListScheduledActions$)
     .build() {
 }
 
-class ListSnapshotCopyConfigurationsCommand extends client.Command
+class ListSnapshotCopyConfigurationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListSnapshotCopyConfigurations", {})
     .n("RedshiftServerlessClient", "ListSnapshotCopyConfigurationsCommand")
-    .sc(schemas_0.ListSnapshotCopyConfigurations$)
+    .sc(ListSnapshotCopyConfigurations$)
     .build() {
 }
 
-class ListSnapshotsCommand extends client.Command
+class ListSnapshotsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListSnapshots", {})
     .n("RedshiftServerlessClient", "ListSnapshotsCommand")
-    .sc(schemas_0.ListSnapshots$)
+    .sc(ListSnapshots$)
     .build() {
 }
 
-class ListTableRestoreStatusCommand extends client.Command
+class ListTableRestoreStatusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListTableRestoreStatus", {})
     .n("RedshiftServerlessClient", "ListTableRestoreStatusCommand")
-    .sc(schemas_0.ListTableRestoreStatus$)
+    .sc(ListTableRestoreStatus$)
     .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("RedshiftServerless", "ListTagsForResource", {})
     .n("RedshiftServerlessClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class ListTracksCommand extends client.Command
+class ListTracksCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListTracks", {})
     .n("RedshiftServerlessClient", "ListTracksCommand")
-    .sc(schemas_0.ListTracks$)
+    .sc(ListTracks$)
     .build() {
 }
 
-class ListUsageLimitsCommand extends client.Command
+class ListUsageLimitsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListUsageLimits", {})
     .n("RedshiftServerlessClient", "ListUsageLimitsCommand")
-    .sc(schemas_0.ListUsageLimits$)
+    .sc(ListUsageLimits$)
     .build() {
 }
 
-class ListWorkgroupsCommand extends client.Command
+class ListWorkgroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "ListWorkgroups", {})
     .n("RedshiftServerlessClient", "ListWorkgroupsCommand")
-    .sc(schemas_0.ListWorkgroups$)
+    .sc(ListWorkgroups$)
     .build() {
 }
 
-class PutResourcePolicyCommand extends client.Command
+class PutResourcePolicyCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "PutResourcePolicy", {})
     .n("RedshiftServerlessClient", "PutResourcePolicyCommand")
-    .sc(schemas_0.PutResourcePolicy$)
+    .sc(PutResourcePolicy$)
     .build() {
 }
 
-class RestoreFromRecoveryPointCommand extends client.Command
+class RestoreFromRecoveryPointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "RestoreFromRecoveryPoint", {})
     .n("RedshiftServerlessClient", "RestoreFromRecoveryPointCommand")
-    .sc(schemas_0.RestoreFromRecoveryPoint$)
+    .sc(RestoreFromRecoveryPoint$)
     .build() {
 }
 
-class RestoreFromSnapshotCommand extends client.Command
+class RestoreFromSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "RestoreFromSnapshot", {})
     .n("RedshiftServerlessClient", "RestoreFromSnapshotCommand")
-    .sc(schemas_0.RestoreFromSnapshot$)
+    .sc(RestoreFromSnapshot$)
     .build() {
 }
 
-class RestoreTableFromRecoveryPointCommand extends client.Command
+class RestoreTableFromRecoveryPointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "RestoreTableFromRecoveryPoint", {})
     .n("RedshiftServerlessClient", "RestoreTableFromRecoveryPointCommand")
-    .sc(schemas_0.RestoreTableFromRecoveryPoint$)
+    .sc(RestoreTableFromRecoveryPoint$)
     .build() {
 }
 
-class RestoreTableFromSnapshotCommand extends client.Command
+class RestoreTableFromSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "RestoreTableFromSnapshot", {})
     .n("RedshiftServerlessClient", "RestoreTableFromSnapshotCommand")
-    .sc(schemas_0.RestoreTableFromSnapshot$)
+    .sc(RestoreTableFromSnapshot$)
     .build() {
 }
 
-class TagResourceCommand extends client.Command
+class TagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "TagResource", {})
     .n("RedshiftServerlessClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
+    .sc(TagResource$)
     .build() {
 }
 
-class UntagResourceCommand extends client.Command
+class UntagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "UntagResource", {})
     .n("RedshiftServerlessClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateCustomDomainAssociationCommand extends client.Command
+class UpdateCustomDomainAssociationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "UpdateCustomDomainAssociation", {})
     .n("RedshiftServerlessClient", "UpdateCustomDomainAssociationCommand")
-    .sc(schemas_0.UpdateCustomDomainAssociation$)
+    .sc(UpdateCustomDomainAssociation$)
     .build() {
 }
 
-class UpdateEndpointAccessCommand extends client.Command
+class UpdateEndpointAccessCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "UpdateEndpointAccess", {})
     .n("RedshiftServerlessClient", "UpdateEndpointAccessCommand")
-    .sc(schemas_0.UpdateEndpointAccess$)
+    .sc(UpdateEndpointAccess$)
     .build() {
 }
 
-class UpdateLakehouseConfigurationCommand extends client.Command
+class UpdateLakehouseConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "UpdateLakehouseConfiguration", {})
     .n("RedshiftServerlessClient", "UpdateLakehouseConfigurationCommand")
-    .sc(schemas_0.UpdateLakehouseConfiguration$)
+    .sc(UpdateLakehouseConfiguration$)
     .build() {
 }
 
-class UpdateNamespaceCommand extends client.Command
+class UpdateNamespaceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "UpdateNamespace", {})
     .n("RedshiftServerlessClient", "UpdateNamespaceCommand")
-    .sc(schemas_0.UpdateNamespace$)
+    .sc(UpdateNamespace$)
     .build() {
 }
 
-class UpdateScheduledActionCommand extends client.Command
+class UpdateScheduledActionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "UpdateScheduledAction", {})
     .n("RedshiftServerlessClient", "UpdateScheduledActionCommand")
-    .sc(schemas_0.UpdateScheduledAction$)
+    .sc(UpdateScheduledAction$)
     .build() {
 }
 
-class UpdateSnapshotCommand extends client.Command
+class UpdateSnapshotCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "UpdateSnapshot", {})
     .n("RedshiftServerlessClient", "UpdateSnapshotCommand")
-    .sc(schemas_0.UpdateSnapshot$)
+    .sc(UpdateSnapshot$)
     .build() {
 }
 
-class UpdateSnapshotCopyConfigurationCommand extends client.Command
+class UpdateSnapshotCopyConfigurationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "UpdateSnapshotCopyConfiguration", {})
     .n("RedshiftServerlessClient", "UpdateSnapshotCopyConfigurationCommand")
-    .sc(schemas_0.UpdateSnapshotCopyConfiguration$)
+    .sc(UpdateSnapshotCopyConfiguration$)
     .build() {
 }
 
-class UpdateUsageLimitCommand extends client.Command
+class UpdateUsageLimitCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "UpdateUsageLimit", {})
     .n("RedshiftServerlessClient", "UpdateUsageLimitCommand")
-    .sc(schemas_0.UpdateUsageLimit$)
+    .sc(UpdateUsageLimit$)
     .build() {
 }
 
-class UpdateWorkgroupCommand extends client.Command
+class UpdateWorkgroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("RedshiftServerless", "UpdateWorkgroup", {})
     .n("RedshiftServerlessClient", "UpdateWorkgroupCommand")
-    .sc(schemas_0.UpdateWorkgroup$)
+    .sc(UpdateWorkgroup$)
     .build() {
 }
 
-const paginateListCustomDomainAssociations = core.createPaginator(RedshiftServerlessClient, ListCustomDomainAssociationsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListCustomDomainAssociations = createPaginator(RedshiftServerlessClient, ListCustomDomainAssociationsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListEndpointAccess = core.createPaginator(RedshiftServerlessClient, ListEndpointAccessCommand, "nextToken", "nextToken", "maxResults");
+const paginateListEndpointAccess = createPaginator(RedshiftServerlessClient, ListEndpointAccessCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListManagedWorkgroups = core.createPaginator(RedshiftServerlessClient, ListManagedWorkgroupsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListManagedWorkgroups = createPaginator(RedshiftServerlessClient, ListManagedWorkgroupsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListNamespaces = core.createPaginator(RedshiftServerlessClient, ListNamespacesCommand, "nextToken", "nextToken", "maxResults");
+const paginateListNamespaces = createPaginator(RedshiftServerlessClient, ListNamespacesCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListRecoveryPoints = core.createPaginator(RedshiftServerlessClient, ListRecoveryPointsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListRecoveryPoints = createPaginator(RedshiftServerlessClient, ListRecoveryPointsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListReservationOfferings = core.createPaginator(RedshiftServerlessClient, ListReservationOfferingsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListReservationOfferings = createPaginator(RedshiftServerlessClient, ListReservationOfferingsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListReservations = core.createPaginator(RedshiftServerlessClient, ListReservationsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListReservations = createPaginator(RedshiftServerlessClient, ListReservationsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListScheduledActions = core.createPaginator(RedshiftServerlessClient, ListScheduledActionsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListScheduledActions = createPaginator(RedshiftServerlessClient, ListScheduledActionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListSnapshotCopyConfigurations = core.createPaginator(RedshiftServerlessClient, ListSnapshotCopyConfigurationsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListSnapshotCopyConfigurations = createPaginator(RedshiftServerlessClient, ListSnapshotCopyConfigurationsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListSnapshots = core.createPaginator(RedshiftServerlessClient, ListSnapshotsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListSnapshots = createPaginator(RedshiftServerlessClient, ListSnapshotsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListTableRestoreStatus = core.createPaginator(RedshiftServerlessClient, ListTableRestoreStatusCommand, "nextToken", "nextToken", "maxResults");
+const paginateListTableRestoreStatus = createPaginator(RedshiftServerlessClient, ListTableRestoreStatusCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListTracks = core.createPaginator(RedshiftServerlessClient, ListTracksCommand, "nextToken", "nextToken", "maxResults");
+const paginateListTracks = createPaginator(RedshiftServerlessClient, ListTracksCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListUsageLimits = core.createPaginator(RedshiftServerlessClient, ListUsageLimitsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListUsageLimits = createPaginator(RedshiftServerlessClient, ListUsageLimitsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListWorkgroups = core.createPaginator(RedshiftServerlessClient, ListWorkgroupsCommand, "nextToken", "nextToken", "maxResults");
+const paginateListWorkgroups = createPaginator(RedshiftServerlessClient, ListWorkgroupsCommand, "nextToken", "nextToken", "maxResults");
 
 const commands = {
     ConvertRecoveryPointToSnapshotCommand,
@@ -1001,7 +1004,7 @@ const paginators = {
 };
 class RedshiftServerless extends RedshiftServerlessClient {
 }
-client.createAggregatedClient(commands, RedshiftServerless, { paginators });
+createAggregatedClient(commands, RedshiftServerless, { paginators });
 
 const SnapshotStatus = {
     AVAILABLE: "AVAILABLE",
@@ -1069,9 +1072,6 @@ const ManagedWorkgroupStatus = {
     NOT_AVAILABLE: "NOT_AVAILABLE",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.RedshiftServerlessServiceException = RedshiftServerlessServiceException.RedshiftServerlessServiceException;
 exports.ConvertRecoveryPointToSnapshotCommand = ConvertRecoveryPointToSnapshotCommand;
 exports.CreateCustomDomainAssociationCommand = CreateCustomDomainAssociationCommand;
 exports.CreateEndpointAccessCommand = CreateEndpointAccessCommand;
@@ -1166,23 +1166,3 @@ exports.paginateListTableRestoreStatus = paginateListTableRestoreStatus;
 exports.paginateListTracks = paginateListTracks;
 exports.paginateListUsageLimits = paginateListUsageLimits;
 exports.paginateListWorkgroups = paginateListWorkgroups;
-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];
-});