@aws-sdk/client-forecast 3.1068.0 → 3.1070.0

package/dist-cjs/index.js

@@ -1,18 +1,21 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var ForecastServiceException = require('./models/ForecastServiceException');
+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, defaultForecastHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { CreateAutoPredictor$, CreateDataset$, CreateDatasetGroup$, CreateDatasetImportJob$, CreateExplainability$, CreateExplainabilityExport$, CreateForecast$, CreateForecastExportJob$, CreateMonitor$, CreatePredictorBacktestExportJob$, CreatePredictor$, CreateWhatIfAnalysis$, CreateWhatIfForecast$, CreateWhatIfForecastExport$, DeleteDataset$, DeleteDatasetGroup$, DeleteDatasetImportJob$, DeleteExplainability$, DeleteExplainabilityExport$, DeleteForecast$, DeleteForecastExportJob$, DeleteMonitor$, DeletePredictorBacktestExportJob$, DeletePredictor$, DeleteResourceTree$, DeleteWhatIfAnalysis$, DeleteWhatIfForecast$, DeleteWhatIfForecastExport$, DescribeAutoPredictor$, DescribeDataset$, DescribeDatasetGroup$, DescribeDatasetImportJob$, DescribeExplainability$, DescribeExplainabilityExport$, DescribeForecast$, DescribeForecastExportJob$, DescribeMonitor$, DescribePredictorBacktestExportJob$, DescribePredictor$, DescribeWhatIfAnalysis$, DescribeWhatIfForecast$, DescribeWhatIfForecastExport$, GetAccuracyMetrics$, ListDatasetGroups$, ListDatasetImportJobs$, ListDatasets$, ListExplainabilities$, ListExplainabilityExports$, ListForecastExportJobs$, ListForecasts$, ListMonitorEvaluations$, ListMonitors$, ListPredictorBacktestExportJobs$, ListPredictors$, ListTagsForResource$, ListWhatIfAnalyses$, ListWhatIfForecastExports$, ListWhatIfForecasts$, ResumeResource$, StopResource$, TagResource$, UntagResource$, UpdateDatasetGroup$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { ForecastServiceException } = require("./models/ForecastServiceException");
+exports.ForecastServiceException = ForecastServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,829 +71,829 @@ 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 ForecastClient extends client.Client {
+class ForecastClient 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.defaultForecastHttpAuthSchemeParametersProvider,
-            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: defaultForecastHttpAuthSchemeParametersProvider,
+            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 CreateAutoPredictorCommand extends client.Command
+class CreateAutoPredictorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateAutoPredictor", {})
     .n("ForecastClient", "CreateAutoPredictorCommand")
-    .sc(schemas_0.CreateAutoPredictor$)
+    .sc(CreateAutoPredictor$)
     .build() {
 }
 
-class CreateDatasetCommand extends client.Command
+class CreateDatasetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateDataset", {})
     .n("ForecastClient", "CreateDatasetCommand")
-    .sc(schemas_0.CreateDataset$)
+    .sc(CreateDataset$)
     .build() {
 }
 
-class CreateDatasetGroupCommand extends client.Command
+class CreateDatasetGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateDatasetGroup", {})
     .n("ForecastClient", "CreateDatasetGroupCommand")
-    .sc(schemas_0.CreateDatasetGroup$)
+    .sc(CreateDatasetGroup$)
     .build() {
 }
 
-class CreateDatasetImportJobCommand extends client.Command
+class CreateDatasetImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateDatasetImportJob", {})
     .n("ForecastClient", "CreateDatasetImportJobCommand")
-    .sc(schemas_0.CreateDatasetImportJob$)
+    .sc(CreateDatasetImportJob$)
     .build() {
 }
 
-class CreateExplainabilityCommand extends client.Command
+class CreateExplainabilityCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateExplainability", {})
     .n("ForecastClient", "CreateExplainabilityCommand")
-    .sc(schemas_0.CreateExplainability$)
+    .sc(CreateExplainability$)
     .build() {
 }
 
-class CreateExplainabilityExportCommand extends client.Command
+class CreateExplainabilityExportCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateExplainabilityExport", {})
     .n("ForecastClient", "CreateExplainabilityExportCommand")
-    .sc(schemas_0.CreateExplainabilityExport$)
+    .sc(CreateExplainabilityExport$)
     .build() {
 }
 
-class CreateForecastCommand extends client.Command
+class CreateForecastCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateForecast", {})
     .n("ForecastClient", "CreateForecastCommand")
-    .sc(schemas_0.CreateForecast$)
+    .sc(CreateForecast$)
     .build() {
 }
 
-class CreateForecastExportJobCommand extends client.Command
+class CreateForecastExportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateForecastExportJob", {})
     .n("ForecastClient", "CreateForecastExportJobCommand")
-    .sc(schemas_0.CreateForecastExportJob$)
+    .sc(CreateForecastExportJob$)
     .build() {
 }
 
-class CreateMonitorCommand extends client.Command
+class CreateMonitorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateMonitor", {})
     .n("ForecastClient", "CreateMonitorCommand")
-    .sc(schemas_0.CreateMonitor$)
+    .sc(CreateMonitor$)
     .build() {
 }
 
-class CreatePredictorBacktestExportJobCommand extends client.Command
+class CreatePredictorBacktestExportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreatePredictorBacktestExportJob", {})
     .n("ForecastClient", "CreatePredictorBacktestExportJobCommand")
-    .sc(schemas_0.CreatePredictorBacktestExportJob$)
+    .sc(CreatePredictorBacktestExportJob$)
     .build() {
 }
 
-class CreatePredictorCommand extends client.Command
+class CreatePredictorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreatePredictor", {})
     .n("ForecastClient", "CreatePredictorCommand")
-    .sc(schemas_0.CreatePredictor$)
+    .sc(CreatePredictor$)
     .build() {
 }
 
-class CreateWhatIfAnalysisCommand extends client.Command
+class CreateWhatIfAnalysisCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateWhatIfAnalysis", {})
     .n("ForecastClient", "CreateWhatIfAnalysisCommand")
-    .sc(schemas_0.CreateWhatIfAnalysis$)
+    .sc(CreateWhatIfAnalysis$)
     .build() {
 }
 
-class CreateWhatIfForecastCommand extends client.Command
+class CreateWhatIfForecastCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateWhatIfForecast", {})
     .n("ForecastClient", "CreateWhatIfForecastCommand")
-    .sc(schemas_0.CreateWhatIfForecast$)
+    .sc(CreateWhatIfForecast$)
     .build() {
 }
 
-class CreateWhatIfForecastExportCommand extends client.Command
+class CreateWhatIfForecastExportCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "CreateWhatIfForecastExport", {})
     .n("ForecastClient", "CreateWhatIfForecastExportCommand")
-    .sc(schemas_0.CreateWhatIfForecastExport$)
+    .sc(CreateWhatIfForecastExport$)
     .build() {
 }
 
-class DeleteDatasetCommand extends client.Command
+class DeleteDatasetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteDataset", {})
     .n("ForecastClient", "DeleteDatasetCommand")
-    .sc(schemas_0.DeleteDataset$)
+    .sc(DeleteDataset$)
     .build() {
 }
 
-class DeleteDatasetGroupCommand extends client.Command
+class DeleteDatasetGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteDatasetGroup", {})
     .n("ForecastClient", "DeleteDatasetGroupCommand")
-    .sc(schemas_0.DeleteDatasetGroup$)
+    .sc(DeleteDatasetGroup$)
     .build() {
 }
 
-class DeleteDatasetImportJobCommand extends client.Command
+class DeleteDatasetImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteDatasetImportJob", {})
     .n("ForecastClient", "DeleteDatasetImportJobCommand")
-    .sc(schemas_0.DeleteDatasetImportJob$)
+    .sc(DeleteDatasetImportJob$)
     .build() {
 }
 
-class DeleteExplainabilityCommand extends client.Command
+class DeleteExplainabilityCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteExplainability", {})
     .n("ForecastClient", "DeleteExplainabilityCommand")
-    .sc(schemas_0.DeleteExplainability$)
+    .sc(DeleteExplainability$)
     .build() {
 }
 
-class DeleteExplainabilityExportCommand extends client.Command
+class DeleteExplainabilityExportCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteExplainabilityExport", {})
     .n("ForecastClient", "DeleteExplainabilityExportCommand")
-    .sc(schemas_0.DeleteExplainabilityExport$)
+    .sc(DeleteExplainabilityExport$)
     .build() {
 }
 
-class DeleteForecastCommand extends client.Command
+class DeleteForecastCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteForecast", {})
     .n("ForecastClient", "DeleteForecastCommand")
-    .sc(schemas_0.DeleteForecast$)
+    .sc(DeleteForecast$)
     .build() {
 }
 
-class DeleteForecastExportJobCommand extends client.Command
+class DeleteForecastExportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteForecastExportJob", {})
     .n("ForecastClient", "DeleteForecastExportJobCommand")
-    .sc(schemas_0.DeleteForecastExportJob$)
+    .sc(DeleteForecastExportJob$)
     .build() {
 }
 
-class DeleteMonitorCommand extends client.Command
+class DeleteMonitorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteMonitor", {})
     .n("ForecastClient", "DeleteMonitorCommand")
-    .sc(schemas_0.DeleteMonitor$)
+    .sc(DeleteMonitor$)
     .build() {
 }
 
-class DeletePredictorBacktestExportJobCommand extends client.Command
+class DeletePredictorBacktestExportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeletePredictorBacktestExportJob", {})
     .n("ForecastClient", "DeletePredictorBacktestExportJobCommand")
-    .sc(schemas_0.DeletePredictorBacktestExportJob$)
+    .sc(DeletePredictorBacktestExportJob$)
     .build() {
 }
 
-class DeletePredictorCommand extends client.Command
+class DeletePredictorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeletePredictor", {})
     .n("ForecastClient", "DeletePredictorCommand")
-    .sc(schemas_0.DeletePredictor$)
+    .sc(DeletePredictor$)
     .build() {
 }
 
-class DeleteResourceTreeCommand extends client.Command
+class DeleteResourceTreeCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteResourceTree", {})
     .n("ForecastClient", "DeleteResourceTreeCommand")
-    .sc(schemas_0.DeleteResourceTree$)
+    .sc(DeleteResourceTree$)
     .build() {
 }
 
-class DeleteWhatIfAnalysisCommand extends client.Command
+class DeleteWhatIfAnalysisCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteWhatIfAnalysis", {})
     .n("ForecastClient", "DeleteWhatIfAnalysisCommand")
-    .sc(schemas_0.DeleteWhatIfAnalysis$)
+    .sc(DeleteWhatIfAnalysis$)
     .build() {
 }
 
-class DeleteWhatIfForecastCommand extends client.Command
+class DeleteWhatIfForecastCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteWhatIfForecast", {})
     .n("ForecastClient", "DeleteWhatIfForecastCommand")
-    .sc(schemas_0.DeleteWhatIfForecast$)
+    .sc(DeleteWhatIfForecast$)
     .build() {
 }
 
-class DeleteWhatIfForecastExportCommand extends client.Command
+class DeleteWhatIfForecastExportCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DeleteWhatIfForecastExport", {})
     .n("ForecastClient", "DeleteWhatIfForecastExportCommand")
-    .sc(schemas_0.DeleteWhatIfForecastExport$)
+    .sc(DeleteWhatIfForecastExport$)
     .build() {
 }
 
-class DescribeAutoPredictorCommand extends client.Command
+class DescribeAutoPredictorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeAutoPredictor", {})
     .n("ForecastClient", "DescribeAutoPredictorCommand")
-    .sc(schemas_0.DescribeAutoPredictor$)
+    .sc(DescribeAutoPredictor$)
     .build() {
 }
 
-class DescribeDatasetCommand extends client.Command
+class DescribeDatasetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeDataset", {})
     .n("ForecastClient", "DescribeDatasetCommand")
-    .sc(schemas_0.DescribeDataset$)
+    .sc(DescribeDataset$)
     .build() {
 }
 
-class DescribeDatasetGroupCommand extends client.Command
+class DescribeDatasetGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeDatasetGroup", {})
     .n("ForecastClient", "DescribeDatasetGroupCommand")
-    .sc(schemas_0.DescribeDatasetGroup$)
+    .sc(DescribeDatasetGroup$)
     .build() {
 }
 
-class DescribeDatasetImportJobCommand extends client.Command
+class DescribeDatasetImportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeDatasetImportJob", {})
     .n("ForecastClient", "DescribeDatasetImportJobCommand")
-    .sc(schemas_0.DescribeDatasetImportJob$)
+    .sc(DescribeDatasetImportJob$)
     .build() {
 }
 
-class DescribeExplainabilityCommand extends client.Command
+class DescribeExplainabilityCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeExplainability", {})
     .n("ForecastClient", "DescribeExplainabilityCommand")
-    .sc(schemas_0.DescribeExplainability$)
+    .sc(DescribeExplainability$)
     .build() {
 }
 
-class DescribeExplainabilityExportCommand extends client.Command
+class DescribeExplainabilityExportCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeExplainabilityExport", {})
     .n("ForecastClient", "DescribeExplainabilityExportCommand")
-    .sc(schemas_0.DescribeExplainabilityExport$)
+    .sc(DescribeExplainabilityExport$)
     .build() {
 }
 
-class DescribeForecastCommand extends client.Command
+class DescribeForecastCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeForecast", {})
     .n("ForecastClient", "DescribeForecastCommand")
-    .sc(schemas_0.DescribeForecast$)
+    .sc(DescribeForecast$)
     .build() {
 }
 
-class DescribeForecastExportJobCommand extends client.Command
+class DescribeForecastExportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeForecastExportJob", {})
     .n("ForecastClient", "DescribeForecastExportJobCommand")
-    .sc(schemas_0.DescribeForecastExportJob$)
+    .sc(DescribeForecastExportJob$)
     .build() {
 }
 
-class DescribeMonitorCommand extends client.Command
+class DescribeMonitorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeMonitor", {})
     .n("ForecastClient", "DescribeMonitorCommand")
-    .sc(schemas_0.DescribeMonitor$)
+    .sc(DescribeMonitor$)
     .build() {
 }
 
-class DescribePredictorBacktestExportJobCommand extends client.Command
+class DescribePredictorBacktestExportJobCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribePredictorBacktestExportJob", {})
     .n("ForecastClient", "DescribePredictorBacktestExportJobCommand")
-    .sc(schemas_0.DescribePredictorBacktestExportJob$)
+    .sc(DescribePredictorBacktestExportJob$)
     .build() {
 }
 
-class DescribePredictorCommand extends client.Command
+class DescribePredictorCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribePredictor", {})
     .n("ForecastClient", "DescribePredictorCommand")
-    .sc(schemas_0.DescribePredictor$)
+    .sc(DescribePredictor$)
     .build() {
 }
 
-class DescribeWhatIfAnalysisCommand extends client.Command
+class DescribeWhatIfAnalysisCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeWhatIfAnalysis", {})
     .n("ForecastClient", "DescribeWhatIfAnalysisCommand")
-    .sc(schemas_0.DescribeWhatIfAnalysis$)
+    .sc(DescribeWhatIfAnalysis$)
     .build() {
 }
 
-class DescribeWhatIfForecastCommand extends client.Command
+class DescribeWhatIfForecastCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeWhatIfForecast", {})
     .n("ForecastClient", "DescribeWhatIfForecastCommand")
-    .sc(schemas_0.DescribeWhatIfForecast$)
+    .sc(DescribeWhatIfForecast$)
     .build() {
 }
 
-class DescribeWhatIfForecastExportCommand extends client.Command
+class DescribeWhatIfForecastExportCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "DescribeWhatIfForecastExport", {})
     .n("ForecastClient", "DescribeWhatIfForecastExportCommand")
-    .sc(schemas_0.DescribeWhatIfForecastExport$)
+    .sc(DescribeWhatIfForecastExport$)
     .build() {
 }
 
-class GetAccuracyMetricsCommand extends client.Command
+class GetAccuracyMetricsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "GetAccuracyMetrics", {})
     .n("ForecastClient", "GetAccuracyMetricsCommand")
-    .sc(schemas_0.GetAccuracyMetrics$)
+    .sc(GetAccuracyMetrics$)
     .build() {
 }
 
-class ListDatasetGroupsCommand extends client.Command
+class ListDatasetGroupsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListDatasetGroups", {})
     .n("ForecastClient", "ListDatasetGroupsCommand")
-    .sc(schemas_0.ListDatasetGroups$)
+    .sc(ListDatasetGroups$)
     .build() {
 }
 
-class ListDatasetImportJobsCommand extends client.Command
+class ListDatasetImportJobsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListDatasetImportJobs", {})
     .n("ForecastClient", "ListDatasetImportJobsCommand")
-    .sc(schemas_0.ListDatasetImportJobs$)
+    .sc(ListDatasetImportJobs$)
     .build() {
 }
 
-class ListDatasetsCommand extends client.Command
+class ListDatasetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListDatasets", {})
     .n("ForecastClient", "ListDatasetsCommand")
-    .sc(schemas_0.ListDatasets$)
+    .sc(ListDatasets$)
     .build() {
 }
 
-class ListExplainabilitiesCommand extends client.Command
+class ListExplainabilitiesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListExplainabilities", {})
     .n("ForecastClient", "ListExplainabilitiesCommand")
-    .sc(schemas_0.ListExplainabilities$)
+    .sc(ListExplainabilities$)
     .build() {
 }
 
-class ListExplainabilityExportsCommand extends client.Command
+class ListExplainabilityExportsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListExplainabilityExports", {})
     .n("ForecastClient", "ListExplainabilityExportsCommand")
-    .sc(schemas_0.ListExplainabilityExports$)
+    .sc(ListExplainabilityExports$)
     .build() {
 }
 
-class ListForecastExportJobsCommand extends client.Command
+class ListForecastExportJobsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListForecastExportJobs", {})
     .n("ForecastClient", "ListForecastExportJobsCommand")
-    .sc(schemas_0.ListForecastExportJobs$)
+    .sc(ListForecastExportJobs$)
     .build() {
 }
 
-class ListForecastsCommand extends client.Command
+class ListForecastsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListForecasts", {})
     .n("ForecastClient", "ListForecastsCommand")
-    .sc(schemas_0.ListForecasts$)
+    .sc(ListForecasts$)
     .build() {
 }
 
-class ListMonitorEvaluationsCommand extends client.Command
+class ListMonitorEvaluationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListMonitorEvaluations", {})
     .n("ForecastClient", "ListMonitorEvaluationsCommand")
-    .sc(schemas_0.ListMonitorEvaluations$)
+    .sc(ListMonitorEvaluations$)
     .build() {
 }
 
-class ListMonitorsCommand extends client.Command
+class ListMonitorsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListMonitors", {})
     .n("ForecastClient", "ListMonitorsCommand")
-    .sc(schemas_0.ListMonitors$)
+    .sc(ListMonitors$)
     .build() {
 }
 
-class ListPredictorBacktestExportJobsCommand extends client.Command
+class ListPredictorBacktestExportJobsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListPredictorBacktestExportJobs", {})
     .n("ForecastClient", "ListPredictorBacktestExportJobsCommand")
-    .sc(schemas_0.ListPredictorBacktestExportJobs$)
+    .sc(ListPredictorBacktestExportJobs$)
     .build() {
 }
 
-class ListPredictorsCommand extends client.Command
+class ListPredictorsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListPredictors", {})
     .n("ForecastClient", "ListPredictorsCommand")
-    .sc(schemas_0.ListPredictors$)
+    .sc(ListPredictors$)
     .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("AmazonForecast", "ListTagsForResource", {})
     .n("ForecastClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class ListWhatIfAnalysesCommand extends client.Command
+class ListWhatIfAnalysesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListWhatIfAnalyses", {})
     .n("ForecastClient", "ListWhatIfAnalysesCommand")
-    .sc(schemas_0.ListWhatIfAnalyses$)
+    .sc(ListWhatIfAnalyses$)
     .build() {
 }
 
-class ListWhatIfForecastExportsCommand extends client.Command
+class ListWhatIfForecastExportsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListWhatIfForecastExports", {})
     .n("ForecastClient", "ListWhatIfForecastExportsCommand")
-    .sc(schemas_0.ListWhatIfForecastExports$)
+    .sc(ListWhatIfForecastExports$)
     .build() {
 }
 
-class ListWhatIfForecastsCommand extends client.Command
+class ListWhatIfForecastsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ListWhatIfForecasts", {})
     .n("ForecastClient", "ListWhatIfForecastsCommand")
-    .sc(schemas_0.ListWhatIfForecasts$)
+    .sc(ListWhatIfForecasts$)
     .build() {
 }
 
-class ResumeResourceCommand extends client.Command
+class ResumeResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "ResumeResource", {})
     .n("ForecastClient", "ResumeResourceCommand")
-    .sc(schemas_0.ResumeResource$)
+    .sc(ResumeResource$)
     .build() {
 }
 
-class StopResourceCommand extends client.Command
+class StopResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "StopResource", {})
     .n("ForecastClient", "StopResourceCommand")
-    .sc(schemas_0.StopResource$)
+    .sc(StopResource$)
     .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("AmazonForecast", "TagResource", {})
     .n("ForecastClient", "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("AmazonForecast", "UntagResource", {})
     .n("ForecastClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateDatasetGroupCommand extends client.Command
+class UpdateDatasetGroupCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonForecast", "UpdateDatasetGroup", {})
     .n("ForecastClient", "UpdateDatasetGroupCommand")
-    .sc(schemas_0.UpdateDatasetGroup$)
+    .sc(UpdateDatasetGroup$)
     .build() {
 }
 
-const paginateListDatasetGroups = core.createPaginator(ForecastClient, ListDatasetGroupsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListDatasetGroups = createPaginator(ForecastClient, ListDatasetGroupsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListDatasetImportJobs = core.createPaginator(ForecastClient, ListDatasetImportJobsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListDatasetImportJobs = createPaginator(ForecastClient, ListDatasetImportJobsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListDatasets = core.createPaginator(ForecastClient, ListDatasetsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListDatasets = createPaginator(ForecastClient, ListDatasetsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListExplainabilities = core.createPaginator(ForecastClient, ListExplainabilitiesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListExplainabilities = createPaginator(ForecastClient, ListExplainabilitiesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListExplainabilityExports = core.createPaginator(ForecastClient, ListExplainabilityExportsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListExplainabilityExports = createPaginator(ForecastClient, ListExplainabilityExportsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListForecastExportJobs = core.createPaginator(ForecastClient, ListForecastExportJobsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListForecastExportJobs = createPaginator(ForecastClient, ListForecastExportJobsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListForecasts = core.createPaginator(ForecastClient, ListForecastsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListForecasts = createPaginator(ForecastClient, ListForecastsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListMonitorEvaluations = core.createPaginator(ForecastClient, ListMonitorEvaluationsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListMonitorEvaluations = createPaginator(ForecastClient, ListMonitorEvaluationsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListMonitors = core.createPaginator(ForecastClient, ListMonitorsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListMonitors = createPaginator(ForecastClient, ListMonitorsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListPredictorBacktestExportJobs = core.createPaginator(ForecastClient, ListPredictorBacktestExportJobsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListPredictorBacktestExportJobs = createPaginator(ForecastClient, ListPredictorBacktestExportJobsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListPredictors = core.createPaginator(ForecastClient, ListPredictorsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListPredictors = createPaginator(ForecastClient, ListPredictorsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListWhatIfAnalyses = core.createPaginator(ForecastClient, ListWhatIfAnalysesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListWhatIfAnalyses = createPaginator(ForecastClient, ListWhatIfAnalysesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListWhatIfForecastExports = core.createPaginator(ForecastClient, ListWhatIfForecastExportsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListWhatIfForecastExports = createPaginator(ForecastClient, ListWhatIfForecastExportsCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListWhatIfForecasts = core.createPaginator(ForecastClient, ListWhatIfForecastsCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListWhatIfForecasts = createPaginator(ForecastClient, ListWhatIfForecastsCommand, "NextToken", "NextToken", "MaxResults");
 
 const commands = {
     CreateAutoPredictorCommand,
@@ -975,7 +978,7 @@ const paginators = {
 };
 class Forecast extends ForecastClient {
 }
-client.createAggregatedClient(commands, Forecast, { paginators });
+createAggregatedClient(commands, Forecast, { paginators });
 
 const Operation = {
     ADD: "ADD",
@@ -1078,9 +1081,6 @@ const FilterConditionString = {
     IS_NOT: "IS_NOT",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.ForecastServiceException = ForecastServiceException.ForecastServiceException;
 exports.AttributeType = AttributeType;
 exports.AutoMLOverrideStrategy = AutoMLOverrideStrategy;
 exports.Condition = Condition;
@@ -1177,23 +1177,3 @@ exports.paginateListPredictors = paginateListPredictors;
 exports.paginateListWhatIfAnalyses = paginateListWhatIfAnalyses;
 exports.paginateListWhatIfForecastExports = paginateListWhatIfForecastExports;
 exports.paginateListWhatIfForecasts = paginateListWhatIfForecasts;
-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];
-});