@aws-sdk/client-machine-learning 3.927.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 var middlewareSdkMachinelearning = require('@aws-sdk/middleware-sdk-machinelearning');
 var utilWaiter = require('@smithy/util-waiter');
 
@@ -93,6 +92,7 @@ class MachineLearningClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.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(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -112,12 +112,12 @@ class MachineLearningClient extends smithyClient.Client {
     }
 }
 
-class MachineLearningServiceException extends smithyClient.ServiceException {
+let MachineLearningServiceException$1 = class MachineLearningServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, MachineLearningServiceException.prototype);
     }
-}
+};
 
 const TaggableResourceType = {
     BATCH_PREDICTION: "BatchPrediction",
@@ -125,7 +125,7 @@ const TaggableResourceType = {
     EVALUATION: "Evaluation",
     ML_MODEL: "MLModel",
 };
-class InternalServerException extends MachineLearningServiceException {
+let InternalServerException$1 = class InternalServerException extends MachineLearningServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     code;
@@ -138,8 +138,8 @@ class InternalServerException extends MachineLearningServiceException {
         Object.setPrototypeOf(this, InternalServerException.prototype);
         this.code = opts.code;
     }
-}
-class InvalidInputException extends MachineLearningServiceException {
+};
+let InvalidInputException$1 = class InvalidInputException extends MachineLearningServiceException$1 {
     name = "InvalidInputException";
     $fault = "client";
     code;
@@ -152,8 +152,8 @@ class InvalidInputException extends MachineLearningServiceException {
         Object.setPrototypeOf(this, InvalidInputException.prototype);
         this.code = opts.code;
     }
-}
-class InvalidTagException extends MachineLearningServiceException {
+};
+let InvalidTagException$1 = class InvalidTagException extends MachineLearningServiceException$1 {
     name = "InvalidTagException";
     $fault = "client";
     constructor(opts) {
@@ -164,8 +164,8 @@ class InvalidTagException extends MachineLearningServiceException {
         });
         Object.setPrototypeOf(this, InvalidTagException.prototype);
     }
-}
-class ResourceNotFoundException extends MachineLearningServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends MachineLearningServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     code;
@@ -178,8 +178,8 @@ class ResourceNotFoundException extends MachineLearningServiceException {
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
         this.code = opts.code;
     }
-}
-class TagLimitExceededException extends MachineLearningServiceException {
+};
+let TagLimitExceededException$1 = class TagLimitExceededException extends MachineLearningServiceException$1 {
     name = "TagLimitExceededException";
     $fault = "client";
     constructor(opts) {
@@ -190,11 +190,11 @@ class TagLimitExceededException extends MachineLearningServiceException {
         });
         Object.setPrototypeOf(this, TagLimitExceededException.prototype);
     }
-}
+};
 const Algorithm = {
     SGD: "sgd",
 };
-class IdempotentParameterMismatchException extends MachineLearningServiceException {
+let IdempotentParameterMismatchException$1 = class IdempotentParameterMismatchException extends MachineLearningServiceException$1 {
     name = "IdempotentParameterMismatchException";
     $fault = "client";
     code;
@@ -207,7 +207,7 @@ class IdempotentParameterMismatchException extends MachineLearningServiceExcepti
         Object.setPrototypeOf(this, IdempotentParameterMismatchException.prototype);
         this.code = opts.code;
     }
-}
+};
 const MLModelType = {
     BINARY: "BINARY",
     MULTICLASS: "MULTICLASS",
@@ -270,7 +270,7 @@ const MLModelFilterVariable = {
     TRAINING_DATASOURCE_ID: "TrainingDataSourceId",
     TRAINING_DATA_URI: "TrainingDataURI",
 };
-class LimitExceededException extends MachineLearningServiceException {
+let LimitExceededException$1 = class LimitExceededException extends MachineLearningServiceException$1 {
     name = "LimitExceededException";
     $fault = "client";
     code;
@@ -283,8 +283,8 @@ class LimitExceededException extends MachineLearningServiceException {
         Object.setPrototypeOf(this, LimitExceededException.prototype);
         this.code = opts.code;
     }
-}
-class PredictorNotMountedException extends MachineLearningServiceException {
+};
+let PredictorNotMountedException$1 = class PredictorNotMountedException extends MachineLearningServiceException$1 {
     name = "PredictorNotMountedException";
     $fault = "client";
     constructor(opts) {
@@ -295,1004 +295,765 @@ class PredictorNotMountedException extends MachineLearningServiceException {
         });
         Object.setPrototypeOf(this, PredictorNotMountedException.prototype);
     }
-}
+};
 const DetailsAttributes = {
     ALGORITHM: "Algorithm",
     PREDICTIVE_MODEL_TYPE: "PredictiveModelType",
 };
-const RDSDatabaseCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Password && { Password: smithyClient.SENSITIVE_STRING }),
-});
-const RDSDataSpecFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.DatabaseCredentials && {
-        DatabaseCredentials: RDSDatabaseCredentialsFilterSensitiveLog(obj.DatabaseCredentials),
-    }),
-});
-const CreateDataSourceFromRDSInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.RDSData && { RDSData: RDSDataSpecFilterSensitiveLog(obj.RDSData) }),
-});
-const RedshiftDatabaseCredentialsFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Password && { Password: smithyClient.SENSITIVE_STRING }),
-});
-const RedshiftDataSpecFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.DatabaseCredentials && {
-        DatabaseCredentials: RedshiftDatabaseCredentialsFilterSensitiveLog(obj.DatabaseCredentials),
-    }),
-});
-const CreateDataSourceFromRedshiftInputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.DataSpec && { DataSpec: RedshiftDataSpecFilterSensitiveLog(obj.DataSpec) }),
-});
 
-const se_AddTagsCommand = async (input, context) => {
-    const headers = sharedHeaders("AddTags");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateBatchPredictionCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateBatchPrediction");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateDataSourceFromRDSCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateDataSourceFromRDS");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateDataSourceFromRedshiftCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateDataSourceFromRedshift");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateDataSourceFromS3Command = async (input, context) => {
-    const headers = sharedHeaders("CreateDataSourceFromS3");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateEvaluationCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateEvaluation");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateMLModelCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateMLModel");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateRealtimeEndpointCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateRealtimeEndpoint");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteBatchPredictionCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteBatchPrediction");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteDataSourceCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteDataSource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteEvaluationCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteEvaluation");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteMLModelCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteMLModel");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteRealtimeEndpointCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteRealtimeEndpoint");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteTagsCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteTags");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeBatchPredictionsCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeBatchPredictions");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeDataSourcesCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeDataSources");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeEvaluationsCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeEvaluations");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeMLModelsCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeMLModels");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeTagsCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeTags");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetBatchPredictionCommand = async (input, context) => {
-    const headers = sharedHeaders("GetBatchPrediction");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetDataSourceCommand = async (input, context) => {
-    const headers = sharedHeaders("GetDataSource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetEvaluationCommand = async (input, context) => {
-    const headers = sharedHeaders("GetEvaluation");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetMLModelCommand = async (input, context) => {
-    const headers = sharedHeaders("GetMLModel");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_PredictCommand = async (input, context) => {
-    const headers = sharedHeaders("Predict");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateBatchPredictionCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateBatchPrediction");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateDataSourceCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateDataSource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateEvaluationCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateEvaluation");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateMLModelCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateMLModel");
-    let body;
-    body = JSON.stringify(se_UpdateMLModelInput(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_AddTagsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateBatchPredictionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateDataSourceFromRDSCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateDataSourceFromRedshiftCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateDataSourceFromS3Command = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateEvaluationCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateMLModelCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateRealtimeEndpointCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreateRealtimeEndpointOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteBatchPredictionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteDataSourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteEvaluationCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteMLModelCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteRealtimeEndpointCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DeleteRealtimeEndpointOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteTagsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeBatchPredictionsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeBatchPredictionsOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeDataSourcesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeDataSourcesOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeEvaluationsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeEvaluationsOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeMLModelsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeMLModelsOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeTagsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetBatchPredictionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetBatchPredictionOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetDataSourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetDataSourceOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetEvaluationCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetEvaluationOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetMLModelCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetMLModelOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_PredictCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_PredictOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateBatchPredictionCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateDataSourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateEvaluationCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateMLModelCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "InternalServerException":
-        case "com.amazonaws.machinelearning#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "InvalidInputException":
-        case "com.amazonaws.machinelearning#InvalidInputException":
-            throw await de_InvalidInputExceptionRes(parsedOutput);
-        case "InvalidTagException":
-        case "com.amazonaws.machinelearning#InvalidTagException":
-            throw await de_InvalidTagExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.machinelearning#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "TagLimitExceededException":
-        case "com.amazonaws.machinelearning#TagLimitExceededException":
-            throw await de_TagLimitExceededExceptionRes(parsedOutput);
-        case "IdempotentParameterMismatchException":
-        case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
-            throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput);
-        case "LimitExceededException":
-        case "com.amazonaws.machinelearning#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput);
-        case "PredictorNotMountedException":
-        case "com.amazonaws.machinelearning#PredictorNotMountedException":
-            throw await de_PredictorNotMountedExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_IdempotentParameterMismatchExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new IdempotentParameterMismatchException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidInputExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidInputException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InvalidTagExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidTagException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_LimitExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new LimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_PredictorNotMountedExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new PredictorNotMountedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_TagLimitExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new TagLimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const se_UpdateMLModelInput = (input, context) => {
-    return smithyClient.take(input, {
-        MLModelId: [],
-        MLModelName: [],
-        ScoreThreshold: smithyClient.serializeFloat,
-    });
-};
-const de_BatchPrediction = (output, context) => {
-    return smithyClient.take(output, {
-        BatchPredictionDataSourceId: smithyClient.expectString,
-        BatchPredictionId: smithyClient.expectString,
-        ComputeTime: smithyClient.expectLong,
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreatedByIamUser: smithyClient.expectString,
-        FinishedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        InputDataLocationS3: smithyClient.expectString,
-        InvalidRecordCount: smithyClient.expectLong,
-        LastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        MLModelId: smithyClient.expectString,
-        Message: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        OutputUri: smithyClient.expectString,
-        StartedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Status: smithyClient.expectString,
-        TotalRecordCount: smithyClient.expectLong,
-    });
-};
-const de_BatchPredictions = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_BatchPrediction(entry);
-    });
-    return retVal;
-};
-const de_CreateRealtimeEndpointOutput = (output, context) => {
-    return smithyClient.take(output, {
-        MLModelId: smithyClient.expectString,
-        RealtimeEndpointInfo: (_) => de_RealtimeEndpointInfo(_),
-    });
-};
-const de_DataSource = (output, context) => {
-    return smithyClient.take(output, {
-        ComputeStatistics: smithyClient.expectBoolean,
-        ComputeTime: smithyClient.expectLong,
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreatedByIamUser: smithyClient.expectString,
-        DataLocationS3: smithyClient.expectString,
-        DataRearrangement: smithyClient.expectString,
-        DataSizeInBytes: smithyClient.expectLong,
-        DataSourceId: smithyClient.expectString,
-        FinishedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Message: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        NumberOfFiles: smithyClient.expectLong,
-        RDSMetadata: smithyClient._json,
-        RedshiftMetadata: smithyClient._json,
-        RoleARN: smithyClient.expectString,
-        StartedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Status: smithyClient.expectString,
-    });
-};
-const de_DataSources = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_DataSource(entry);
-    });
-    return retVal;
-};
-const de_DeleteRealtimeEndpointOutput = (output, context) => {
-    return smithyClient.take(output, {
-        MLModelId: smithyClient.expectString,
-        RealtimeEndpointInfo: (_) => de_RealtimeEndpointInfo(_),
-    });
-};
-const de_DescribeBatchPredictionsOutput = (output, context) => {
-    return smithyClient.take(output, {
-        NextToken: smithyClient.expectString,
-        Results: (_) => de_BatchPredictions(_),
-    });
-};
-const de_DescribeDataSourcesOutput = (output, context) => {
-    return smithyClient.take(output, {
-        NextToken: smithyClient.expectString,
-        Results: (_) => de_DataSources(_),
-    });
-};
-const de_DescribeEvaluationsOutput = (output, context) => {
-    return smithyClient.take(output, {
-        NextToken: smithyClient.expectString,
-        Results: (_) => de_Evaluations(_),
-    });
-};
-const de_DescribeMLModelsOutput = (output, context) => {
-    return smithyClient.take(output, {
-        NextToken: smithyClient.expectString,
-        Results: (_) => de_MLModels(_),
-    });
-};
-const de_Evaluation = (output, context) => {
-    return smithyClient.take(output, {
-        ComputeTime: smithyClient.expectLong,
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreatedByIamUser: smithyClient.expectString,
-        EvaluationDataSourceId: smithyClient.expectString,
-        EvaluationId: smithyClient.expectString,
-        FinishedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        InputDataLocationS3: smithyClient.expectString,
-        LastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        MLModelId: smithyClient.expectString,
-        Message: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        PerformanceMetrics: smithyClient._json,
-        StartedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Status: smithyClient.expectString,
-    });
-};
-const de_Evaluations = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Evaluation(entry);
-    });
-    return retVal;
-};
-const de_GetBatchPredictionOutput = (output, context) => {
-    return smithyClient.take(output, {
-        BatchPredictionDataSourceId: smithyClient.expectString,
-        BatchPredictionId: smithyClient.expectString,
-        ComputeTime: smithyClient.expectLong,
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreatedByIamUser: smithyClient.expectString,
-        FinishedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        InputDataLocationS3: smithyClient.expectString,
-        InvalidRecordCount: smithyClient.expectLong,
-        LastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LogUri: smithyClient.expectString,
-        MLModelId: smithyClient.expectString,
-        Message: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        OutputUri: smithyClient.expectString,
-        StartedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Status: smithyClient.expectString,
-        TotalRecordCount: smithyClient.expectLong,
-    });
-};
-const de_GetDataSourceOutput = (output, context) => {
-    return smithyClient.take(output, {
-        ComputeStatistics: smithyClient.expectBoolean,
-        ComputeTime: smithyClient.expectLong,
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreatedByIamUser: smithyClient.expectString,
-        DataLocationS3: smithyClient.expectString,
-        DataRearrangement: smithyClient.expectString,
-        DataSizeInBytes: smithyClient.expectLong,
-        DataSourceId: smithyClient.expectString,
-        DataSourceSchema: smithyClient.expectString,
-        FinishedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LogUri: smithyClient.expectString,
-        Message: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        NumberOfFiles: smithyClient.expectLong,
-        RDSMetadata: smithyClient._json,
-        RedshiftMetadata: smithyClient._json,
-        RoleARN: smithyClient.expectString,
-        StartedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Status: smithyClient.expectString,
-    });
-};
-const de_GetEvaluationOutput = (output, context) => {
-    return smithyClient.take(output, {
-        ComputeTime: smithyClient.expectLong,
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreatedByIamUser: smithyClient.expectString,
-        EvaluationDataSourceId: smithyClient.expectString,
-        EvaluationId: smithyClient.expectString,
-        FinishedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        InputDataLocationS3: smithyClient.expectString,
-        LastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LogUri: smithyClient.expectString,
-        MLModelId: smithyClient.expectString,
-        Message: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        PerformanceMetrics: smithyClient._json,
-        StartedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Status: smithyClient.expectString,
-    });
-};
-const de_GetMLModelOutput = (output, context) => {
-    return smithyClient.take(output, {
-        ComputeTime: smithyClient.expectLong,
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreatedByIamUser: smithyClient.expectString,
-        EndpointInfo: (_) => de_RealtimeEndpointInfo(_),
-        FinishedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        InputDataLocationS3: smithyClient.expectString,
-        LastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        LogUri: smithyClient.expectString,
-        MLModelId: smithyClient.expectString,
-        MLModelType: smithyClient.expectString,
-        Message: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        Recipe: smithyClient.expectString,
-        Schema: smithyClient.expectString,
-        ScoreThreshold: smithyClient.limitedParseFloat32,
-        ScoreThresholdLastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        SizeInBytes: smithyClient.expectLong,
-        StartedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Status: smithyClient.expectString,
-        TrainingDataSourceId: smithyClient.expectString,
-        TrainingParameters: smithyClient._json,
-    });
-};
-const de_MLModel = (output, context) => {
-    return smithyClient.take(output, {
-        Algorithm: smithyClient.expectString,
-        ComputeTime: smithyClient.expectLong,
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        CreatedByIamUser: smithyClient.expectString,
-        EndpointInfo: (_) => de_RealtimeEndpointInfo(_),
-        FinishedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        InputDataLocationS3: smithyClient.expectString,
-        LastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        MLModelId: smithyClient.expectString,
-        MLModelType: smithyClient.expectString,
-        Message: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        ScoreThreshold: smithyClient.limitedParseFloat32,
-        ScoreThresholdLastUpdatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        SizeInBytes: smithyClient.expectLong,
-        StartedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Status: smithyClient.expectString,
-        TrainingDataSourceId: smithyClient.expectString,
-        TrainingParameters: smithyClient._json,
-    });
-};
-const de_MLModels = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_MLModel(entry);
-    });
-    return retVal;
-};
-const de_Prediction = (output, context) => {
-    return smithyClient.take(output, {
-        details: smithyClient._json,
-        predictedLabel: smithyClient.expectString,
-        predictedScores: (_) => de_ScoreValuePerLabelMap(_),
-        predictedValue: smithyClient.limitedParseFloat32,
-    });
-};
-const de_PredictOutput = (output, context) => {
-    return smithyClient.take(output, {
-        Prediction: (_) => de_Prediction(_),
-    });
-};
-const de_RealtimeEndpointInfo = (output, context) => {
-    return smithyClient.take(output, {
-        CreatedAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        EndpointStatus: smithyClient.expectString,
-        EndpointUrl: smithyClient.expectString,
-        PeakRequestsPerSecond: smithyClient.expectInt32,
-    });
-};
-const de_ScoreValuePerLabelMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = smithyClient.limitedParseFloat32(value);
-        return acc;
-    }, {});
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
-const throwDefaultError = smithyClient.withBaseException(MachineLearningServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.1",
-        "x-amz-target": `AmazonML_20141212.${operation}`,
-    };
-}
+const _A = "Algorithm";
+const _AT = "AddTags";
+const _ATI = "AddTagsInput";
+const _ATO = "AddTagsOutput";
+const _BP = "BatchPrediction";
+const _BPDSI = "BatchPredictionDataSourceId";
+const _BPI = "BatchPredictionId";
+const _BPN = "BatchPredictionName";
+const _BPa = "BatchPredictions";
+const _CA = "CreatedAt";
+const _CBIU = "CreatedByIamUser";
+const _CBP = "CreateBatchPrediction";
+const _CBPI = "CreateBatchPredictionInput";
+const _CBPO = "CreateBatchPredictionOutput";
+const _CDSFR = "CreateDataSourceFromRedshift";
+const _CDSFRDS = "CreateDataSourceFromRDS";
+const _CDSFRDSI = "CreateDataSourceFromRDSInput";
+const _CDSFRDSO = "CreateDataSourceFromRDSOutput";
+const _CDSFRI = "CreateDataSourceFromRedshiftInput";
+const _CDSFRO = "CreateDataSourceFromRedshiftOutput";
+const _CDSFS = "CreateDataSourceFromS3";
+const _CDSFSI = "CreateDataSourceFromS3Input";
+const _CDSFSO = "CreateDataSourceFromS3Output";
+const _CE = "CreateEvaluation";
+const _CEI = "CreateEvaluationInput";
+const _CEO = "CreateEvaluationOutput";
+const _CI = "ClusterIdentifier";
+const _CMLM = "CreateMLModel";
+const _CMLMI = "CreateMLModelInput";
+const _CMLMO = "CreateMLModelOutput";
+const _CRE = "CreateRealtimeEndpoint";
+const _CREI = "CreateRealtimeEndpointInput";
+const _CREO = "CreateRealtimeEndpointOutput";
+const _CS = "ComputeStatistics";
+const _CT = "ComputeTime";
+const _D = "Database";
+const _DBP = "DeleteBatchPrediction";
+const _DBPI = "DeleteBatchPredictionInput";
+const _DBPIe = "DescribeBatchPredictionsInput";
+const _DBPO = "DeleteBatchPredictionOutput";
+const _DBPOe = "DescribeBatchPredictionsOutput";
+const _DBPe = "DescribeBatchPredictions";
+const _DC = "DatabaseCredentials";
+const _DDS = "DeleteDataSource";
+const _DDSI = "DeleteDataSourceInput";
+const _DDSIe = "DescribeDataSourcesInput";
+const _DDSO = "DeleteDataSourceOutput";
+const _DDSOe = "DescribeDataSourcesOutput";
+const _DDSe = "DescribeDataSources";
+const _DE = "DeleteEvaluation";
+const _DEI = "DeleteEvaluationInput";
+const _DEIe = "DescribeEvaluationsInput";
+const _DEO = "DeleteEvaluationOutput";
+const _DEOe = "DescribeEvaluationsOutput";
+const _DEe = "DescribeEvaluations";
+const _DI = "DatabaseInformation";
+const _DLS = "DataLocationS3";
+const _DMLM = "DeleteMLModel";
+const _DMLMI = "DeleteMLModelInput";
+const _DMLMIe = "DescribeMLModelsInput";
+const _DMLMO = "DeleteMLModelOutput";
+const _DMLMOe = "DescribeMLModelsOutput";
+const _DMLMe = "DescribeMLModels";
+const _DN = "DatabaseName";
+const _DPI = "DataPipelineId";
+const _DR = "DataRearrangement";
+const _DRE = "DeleteRealtimeEndpoint";
+const _DREI = "DeleteRealtimeEndpointInput";
+const _DREO = "DeleteRealtimeEndpointOutput";
+const _DS = "DataSpec";
+const _DSI = "DataSourceId";
+const _DSIB = "DataSizeInBytes";
+const _DSLS = "DataSchemaLocationS3";
+const _DSN = "DataSourceName";
+const _DSS = "DataSourceSchema";
+const _DSU = "DataSchemaUri";
+const _DSa = "DataSource";
+const _DSat = "DataSchema";
+const _DSata = "DataSources";
+const _DT = "DeleteTags";
+const _DTI = "DeleteTagsInput";
+const _DTIe = "DescribeTagsInput";
+const _DTO = "DeleteTagsOutput";
+const _DTOe = "DescribeTagsOutput";
+const _DTe = "DescribeTags";
+const _DUN = "DatabaseUserName";
+const _E = "Evaluation";
+const _EDSI = "EvaluationDataSourceId";
+const _EI = "EvaluationId";
+const _EIn = "EndpointInfo";
+const _EN = "EvaluationName";
+const _EQ = "EQ";
+const _ES = "EndpointStatus";
+const _EU = "EndpointUrl";
+const _Ev = "Evaluations";
+const _FA = "FinishedAt";
+const _FV = "FilterVariable";
+const _GBP = "GetBatchPrediction";
+const _GBPI = "GetBatchPredictionInput";
+const _GBPO = "GetBatchPredictionOutput";
+const _GDS = "GetDataSource";
+const _GDSI = "GetDataSourceInput";
+const _GDSO = "GetDataSourceOutput";
+const _GE = "GE";
+const _GEI = "GetEvaluationInput";
+const _GEO = "GetEvaluationOutput";
+const _GEe = "GetEvaluation";
+const _GMLM = "GetMLModel";
+const _GMLMI = "GetMLModelInput";
+const _GMLMO = "GetMLModelOutput";
+const _GT = "GT";
+const _IDLS = "InputDataLocationS3";
+const _II = "InstanceIdentifier";
+const _IIE = "InvalidInputException";
+const _IPME = "IdempotentParameterMismatchException";
+const _IRC = "InvalidRecordCount";
+const _ISE = "InternalServerException";
+const _ITE = "InvalidTagException";
+const _K = "Key";
+const _L = "Limit";
+const _LE = "LE";
+const _LEE = "LimitExceededException";
+const _LT = "LT";
+const _LU = "LogUri";
+const _LUA = "LastUpdatedAt";
+const _M = "Message";
+const _MLM = "MLModel";
+const _MLMI = "MLModelId";
+const _MLMN = "MLModelName";
+const _MLMT = "MLModelType";
+const _MLMo = "MLModels";
+const _N = "Name";
+const _NE = "NE";
+const _NOF = "NumberOfFiles";
+const _NT = "NextToken";
+const _OU = "OutputUri";
+const _P = "Parameters";
+const _PE = "PredictEndpoint";
+const _PI = "PredictInput";
+const _PM = "PerformanceMetrics";
+const _PNME = "PredictorNotMountedException";
+const _PO = "PredictOutput";
+const _PRPS = "PeakRequestsPerSecond";
+const _Pa = "Password";
+const _Pr = "Prefix";
+const _Pre = "Prediction";
+const _Pred = "Predict";
+const _Pro = "Properties";
+const _R = "Recipe";
+const _RARN = "RoleARN";
+const _RD = "RedshiftDatabase";
+const _RDC = "RedshiftDatabaseCredentials";
+const _RDP = "RedshiftDatabasePassword";
+const _RDS = "RedshiftDataSpec";
+const _RDSD = "RDSData";
+const _RDSDC = "RDSDatabaseCredentials";
+const _RDSDP = "RDSDatabasePassword";
+const _RDSDS = "RDSDataSpec";
+const _RDSDa = "RDSDatabase";
+const _RDSM = "RDSMetadata";
+const _REI = "RealtimeEndpointInfo";
+const _RI = "ResourceId";
+const _RM = "RedshiftMetadata";
+const _RNFE = "ResourceNotFoundException";
+const _RR = "ResourceRole";
+const _RT = "ResourceType";
+const _RU = "RecipeUri";
+const _Re = "Results";
+const _Rec = "Record";
+const _S = "Status";
+const _SA = "StartedAt";
+const _SDS = "S3DataSpec";
+const _SGI = "SecurityGroupIds";
+const _SI = "SubnetId";
+const _SIB = "SizeInBytes";
+const _SO = "SortOrder";
+const _SR = "ServiceRole";
+const _SSL = "S3StagingLocation";
+const _SSQ = "SelectSqlQuery";
+const _ST = "ScoreThreshold";
+const _STLUA = "ScoreThresholdLastUpdatedAt";
+const _Sc = "Schema";
+const _T = "Tags";
+const _TDSI = "TrainingDataSourceId";
+const _TK = "TagKeys";
+const _TL = "TagList";
+const _TLEE = "TagLimitExceededException";
+const _TP = "TrainingParameters";
+const _TRC = "TotalRecordCount";
+const _Ta = "Tag";
+const _U = "Username";
+const _UBP = "UpdateBatchPrediction";
+const _UBPI = "UpdateBatchPredictionInput";
+const _UBPO = "UpdateBatchPredictionOutput";
+const _UDS = "UpdateDataSource";
+const _UDSI = "UpdateDataSourceInput";
+const _UDSO = "UpdateDataSourceOutput";
+const _UE = "UpdateEvaluation";
+const _UEI = "UpdateEvaluationInput";
+const _UEO = "UpdateEvaluationOutput";
+const _UMLM = "UpdateMLModel";
+const _UMLMI = "UpdateMLModelInput";
+const _UMLMO = "UpdateMLModelOutput";
+const _V = "Verbose";
+const _Va = "Value";
+const _c = "client";
+const _co = "code";
+const _d = "details";
+const _e = "error";
+const _hE = "httpError";
+const _m = "message";
+const _pL = "predictedLabel";
+const _pS = "predictedScores";
+const _pV = "predictedValue";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.machinelearning";
+const n0 = "com.amazonaws.machinelearning";
+var RDSDatabasePassword = [0, n0, _RDSDP, 8, 0];
+var RedshiftDatabasePassword = [0, n0, _RDP, 8, 0];
+var AddTagsInput = [3, n0, _ATI, 0, [_T, _RI, _RT], [() => TagList, 0, 0]];
+var AddTagsOutput = [3, n0, _ATO, 0, [_RI, _RT], [0, 0]];
+var BatchPrediction = [
+    3,
+    n0,
+    _BP,
+    0,
+    [_BPI, _MLMI, _BPDSI, _IDLS, _CBIU, _CA, _LUA, _N, _S, _OU, _M, _CT, _FA, _SA, _TRC, _IRC],
+    [0, 0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 1, 4, 4, 1, 1],
+];
+var CreateBatchPredictionInput = [
+    3,
+    n0,
+    _CBPI,
+    0,
+    [_BPI, _BPN, _MLMI, _BPDSI, _OU],
+    [0, 0, 0, 0, 0],
+];
+var CreateBatchPredictionOutput = [3, n0, _CBPO, 0, [_BPI], [0]];
+var CreateDataSourceFromRDSInput = [
+    3,
+    n0,
+    _CDSFRDSI,
+    0,
+    [_DSI, _DSN, _RDSD, _RARN, _CS],
+    [0, 0, [() => RDSDataSpec, 0], 0, 2],
+];
+var CreateDataSourceFromRDSOutput = [3, n0, _CDSFRDSO, 0, [_DSI], [0]];
+var CreateDataSourceFromRedshiftInput = [
+    3,
+    n0,
+    _CDSFRI,
+    0,
+    [_DSI, _DSN, _DS, _RARN, _CS],
+    [0, 0, [() => RedshiftDataSpec, 0], 0, 2],
+];
+var CreateDataSourceFromRedshiftOutput = [3, n0, _CDSFRO, 0, [_DSI], [0]];
+var CreateDataSourceFromS3Input = [
+    3,
+    n0,
+    _CDSFSI,
+    0,
+    [_DSI, _DSN, _DS, _CS],
+    [0, 0, () => S3DataSpec, 2],
+];
+var CreateDataSourceFromS3Output = [3, n0, _CDSFSO, 0, [_DSI], [0]];
+var CreateEvaluationInput = [3, n0, _CEI, 0, [_EI, _EN, _MLMI, _EDSI], [0, 0, 0, 0]];
+var CreateEvaluationOutput = [3, n0, _CEO, 0, [_EI], [0]];
+var CreateMLModelInput = [
+    3,
+    n0,
+    _CMLMI,
+    0,
+    [_MLMI, _MLMN, _MLMT, _P, _TDSI, _R, _RU],
+    [0, 0, 0, 128 | 0, 0, 0, 0],
+];
+var CreateMLModelOutput = [3, n0, _CMLMO, 0, [_MLMI], [0]];
+var CreateRealtimeEndpointInput = [3, n0, _CREI, 0, [_MLMI], [0]];
+var CreateRealtimeEndpointOutput = [
+    3,
+    n0,
+    _CREO,
+    0,
+    [_MLMI, _REI],
+    [0, () => RealtimeEndpointInfo],
+];
+var DataSource = [
+    3,
+    n0,
+    _DSa,
+    0,
+    [_DSI, _DLS, _DR, _CBIU, _CA, _LUA, _DSIB, _NOF, _N, _S, _M, _RM, _RDSM, _RARN, _CS, _CT, _FA, _SA],
+    [0, 0, 0, 0, 4, 4, 1, 1, 0, 0, 0, () => RedshiftMetadata, () => RDSMetadata, 0, 2, 1, 4, 4],
+];
+var DeleteBatchPredictionInput = [3, n0, _DBPI, 0, [_BPI], [0]];
+var DeleteBatchPredictionOutput = [3, n0, _DBPO, 0, [_BPI], [0]];
+var DeleteDataSourceInput = [3, n0, _DDSI, 0, [_DSI], [0]];
+var DeleteDataSourceOutput = [3, n0, _DDSO, 0, [_DSI], [0]];
+var DeleteEvaluationInput = [3, n0, _DEI, 0, [_EI], [0]];
+var DeleteEvaluationOutput = [3, n0, _DEO, 0, [_EI], [0]];
+var DeleteMLModelInput = [3, n0, _DMLMI, 0, [_MLMI], [0]];
+var DeleteMLModelOutput = [3, n0, _DMLMO, 0, [_MLMI], [0]];
+var DeleteRealtimeEndpointInput = [3, n0, _DREI, 0, [_MLMI], [0]];
+var DeleteRealtimeEndpointOutput = [
+    3,
+    n0,
+    _DREO,
+    0,
+    [_MLMI, _REI],
+    [0, () => RealtimeEndpointInfo],
+];
+var DeleteTagsInput = [3, n0, _DTI, 0, [_TK, _RI, _RT], [64 | 0, 0, 0]];
+var DeleteTagsOutput = [3, n0, _DTO, 0, [_RI, _RT], [0, 0]];
+var DescribeBatchPredictionsInput = [
+    3,
+    n0,
+    _DBPIe,
+    0,
+    [_FV, _EQ, _GT, _LT, _GE, _LE, _NE, _Pr, _SO, _NT, _L],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+];
+var DescribeBatchPredictionsOutput = [
+    3,
+    n0,
+    _DBPOe,
+    0,
+    [_Re, _NT],
+    [() => BatchPredictions, 0],
+];
+var DescribeDataSourcesInput = [
+    3,
+    n0,
+    _DDSIe,
+    0,
+    [_FV, _EQ, _GT, _LT, _GE, _LE, _NE, _Pr, _SO, _NT, _L],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+];
+var DescribeDataSourcesOutput = [3, n0, _DDSOe, 0, [_Re, _NT], [() => DataSources, 0]];
+var DescribeEvaluationsInput = [
+    3,
+    n0,
+    _DEIe,
+    0,
+    [_FV, _EQ, _GT, _LT, _GE, _LE, _NE, _Pr, _SO, _NT, _L],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+];
+var DescribeEvaluationsOutput = [3, n0, _DEOe, 0, [_Re, _NT], [() => Evaluations, 0]];
+var DescribeMLModelsInput = [
+    3,
+    n0,
+    _DMLMIe,
+    0,
+    [_FV, _EQ, _GT, _LT, _GE, _LE, _NE, _Pr, _SO, _NT, _L],
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+];
+var DescribeMLModelsOutput = [3, n0, _DMLMOe, 0, [_Re, _NT], [() => MLModels, 0]];
+var DescribeTagsInput = [3, n0, _DTIe, 0, [_RI, _RT], [0, 0]];
+var DescribeTagsOutput = [3, n0, _DTOe, 0, [_RI, _RT, _T], [0, 0, () => TagList]];
+var Evaluation = [
+    3,
+    n0,
+    _E,
+    0,
+    [_EI, _MLMI, _EDSI, _IDLS, _CBIU, _CA, _LUA, _N, _S, _PM, _M, _CT, _FA, _SA],
+    [0, 0, 0, 0, 0, 4, 4, 0, 0, () => PerformanceMetrics, 0, 1, 4, 4],
+];
+var GetBatchPredictionInput = [3, n0, _GBPI, 0, [_BPI], [0]];
+var GetBatchPredictionOutput = [
+    3,
+    n0,
+    _GBPO,
+    0,
+    [_BPI, _MLMI, _BPDSI, _IDLS, _CBIU, _CA, _LUA, _N, _S, _OU, _LU, _M, _CT, _FA, _SA, _TRC, _IRC],
+    [0, 0, 0, 0, 0, 4, 4, 0, 0, 0, 0, 0, 1, 4, 4, 1, 1],
+];
+var GetDataSourceInput = [3, n0, _GDSI, 0, [_DSI, _V], [0, 2]];
+var GetDataSourceOutput = [
+    3,
+    n0,
+    _GDSO,
+    0,
+    [_DSI, _DLS, _DR, _CBIU, _CA, _LUA, _DSIB, _NOF, _N, _S, _LU, _M, _RM, _RDSM, _RARN, _CS, _CT, _FA, _SA, _DSS],
+    [0, 0, 0, 0, 4, 4, 1, 1, 0, 0, 0, 0, () => RedshiftMetadata, () => RDSMetadata, 0, 2, 1, 4, 4, 0],
+];
+var GetEvaluationInput = [3, n0, _GEI, 0, [_EI], [0]];
+var GetEvaluationOutput = [
+    3,
+    n0,
+    _GEO,
+    0,
+    [_EI, _MLMI, _EDSI, _IDLS, _CBIU, _CA, _LUA, _N, _S, _PM, _LU, _M, _CT, _FA, _SA],
+    [0, 0, 0, 0, 0, 4, 4, 0, 0, () => PerformanceMetrics, 0, 0, 1, 4, 4],
+];
+var GetMLModelInput = [3, n0, _GMLMI, 0, [_MLMI, _V], [0, 2]];
+var GetMLModelOutput = [
+    3,
+    n0,
+    _GMLMO,
+    0,
+    [_MLMI, _TDSI, _CBIU, _CA, _LUA, _N, _S, _SIB, _EIn, _TP, _IDLS, _MLMT, _ST, _STLUA, _LU, _M, _CT, _FA, _SA, _R, _Sc],
+    [0, 0, 0, 4, 4, 0, 0, 1, () => RealtimeEndpointInfo, 128 | 0, 0, 0, 1, 4, 0, 0, 1, 4, 4, 0, 0],
+];
+var IdempotentParameterMismatchException = [
+    -3,
+    n0,
+    _IPME,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m, _co],
+    [0, 1],
+];
+schema.TypeRegistry.for(n0).registerError(IdempotentParameterMismatchException, IdempotentParameterMismatchException$1);
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_m, _co],
+    [0, 1],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var InvalidInputException = [
+    -3,
+    n0,
+    _IIE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m, _co],
+    [0, 1],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidInputException, InvalidInputException$1);
+var InvalidTagException = [
+    -3,
+    n0,
+    _ITE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidTagException, InvalidTagException$1);
+var LimitExceededException = [
+    -3,
+    n0,
+    _LEE,
+    {
+        [_e]: _c,
+        [_hE]: 417,
+    },
+    [_m, _co],
+    [0, 1],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1);
+var MLModel = [
+    3,
+    n0,
+    _MLM,
+    0,
+    [_MLMI, _TDSI, _CBIU, _CA, _LUA, _N, _S, _SIB, _EIn, _TP, _IDLS, _A, _MLMT, _ST, _STLUA, _M, _CT, _FA, _SA],
+    [0, 0, 0, 4, 4, 0, 0, 1, () => RealtimeEndpointInfo, 128 | 0, 0, 0, 0, 1, 4, 0, 1, 4, 4],
+];
+var PerformanceMetrics = [3, n0, _PM, 0, [_Pro], [128 | 0]];
+var PredictInput = [3, n0, _PI, 0, [_MLMI, _Rec, _PE], [0, 128 | 0, 0]];
+var Prediction = [3, n0, _Pre, 0, [_pL, _pV, _pS, _d], [0, 1, 128 | 1, 128 | 0]];
+var PredictorNotMountedException = [
+    -3,
+    n0,
+    _PNME,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(PredictorNotMountedException, PredictorNotMountedException$1);
+var PredictOutput = [3, n0, _PO, 0, [_Pre], [() => Prediction]];
+var RDSDatabase = [3, n0, _RDSDa, 0, [_II, _DN], [0, 0]];
+var RDSDatabaseCredentials = [
+    3,
+    n0,
+    _RDSDC,
+    0,
+    [_U, _Pa],
+    [0, [() => RDSDatabasePassword, 0]],
+];
+var RDSDataSpec = [
+    3,
+    n0,
+    _RDSDS,
+    0,
+    [_DI, _SSQ, _DC, _SSL, _DR, _DSat, _DSU, _RR, _SR, _SI, _SGI],
+    [() => RDSDatabase, 0, [() => RDSDatabaseCredentials, 0], 0, 0, 0, 0, 0, 0, 0, 64 | 0],
+];
+var RDSMetadata = [
+    3,
+    n0,
+    _RDSM,
+    0,
+    [_D, _DUN, _SSQ, _RR, _SR, _DPI],
+    [() => RDSDatabase, 0, 0, 0, 0, 0],
+];
+var RealtimeEndpointInfo = [3, n0, _REI, 0, [_PRPS, _CA, _EU, _ES], [1, 4, 0, 0]];
+var RedshiftDatabase = [3, n0, _RD, 0, [_DN, _CI], [0, 0]];
+var RedshiftDatabaseCredentials = [
+    3,
+    n0,
+    _RDC,
+    0,
+    [_U, _Pa],
+    [0, [() => RedshiftDatabasePassword, 0]],
+];
+var RedshiftDataSpec = [
+    3,
+    n0,
+    _RDS,
+    0,
+    [_DI, _SSQ, _DC, _SSL, _DR, _DSat, _DSU],
+    [() => RedshiftDatabase, 0, [() => RedshiftDatabaseCredentials, 0], 0, 0, 0, 0],
+];
+var RedshiftMetadata = [3, n0, _RM, 0, [_RD, _DUN, _SSQ], [() => RedshiftDatabase, 0, 0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m, _co],
+    [0, 1],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var S3DataSpec = [3, n0, _SDS, 0, [_DLS, _DR, _DSat, _DSLS], [0, 0, 0, 0]];
+var Tag = [3, n0, _Ta, 0, [_K, _Va], [0, 0]];
+var TagLimitExceededException = [
+    -3,
+    n0,
+    _TLEE,
+    {
+        [_e]: _c,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TagLimitExceededException, TagLimitExceededException$1);
+var UpdateBatchPredictionInput = [3, n0, _UBPI, 0, [_BPI, _BPN], [0, 0]];
+var UpdateBatchPredictionOutput = [3, n0, _UBPO, 0, [_BPI], [0]];
+var UpdateDataSourceInput = [3, n0, _UDSI, 0, [_DSI, _DSN], [0, 0]];
+var UpdateDataSourceOutput = [3, n0, _UDSO, 0, [_DSI], [0]];
+var UpdateEvaluationInput = [3, n0, _UEI, 0, [_EI, _EN], [0, 0]];
+var UpdateEvaluationOutput = [3, n0, _UEO, 0, [_EI], [0]];
+var UpdateMLModelInput = [3, n0, _UMLMI, 0, [_MLMI, _MLMN, _ST], [0, 0, 1]];
+var UpdateMLModelOutput = [3, n0, _UMLMO, 0, [_MLMI], [0]];
+var MachineLearningServiceException = [-3, _sm, "MachineLearningServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(MachineLearningServiceException, MachineLearningServiceException$1);
+var BatchPredictions = [1, n0, _BPa, 0, () => BatchPrediction];
+var DataSources = [1, n0, _DSata, 0, () => DataSource];
+var Evaluations = [1, n0, _Ev, 0, () => Evaluation];
+var MLModels = [1, n0, _MLMo, 0, () => MLModel];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var AddTags = [9, n0, _AT, 0, () => AddTagsInput, () => AddTagsOutput];
+var CreateBatchPrediction = [
+    9,
+    n0,
+    _CBP,
+    0,
+    () => CreateBatchPredictionInput,
+    () => CreateBatchPredictionOutput,
+];
+var CreateDataSourceFromRDS = [
+    9,
+    n0,
+    _CDSFRDS,
+    0,
+    () => CreateDataSourceFromRDSInput,
+    () => CreateDataSourceFromRDSOutput,
+];
+var CreateDataSourceFromRedshift = [
+    9,
+    n0,
+    _CDSFR,
+    0,
+    () => CreateDataSourceFromRedshiftInput,
+    () => CreateDataSourceFromRedshiftOutput,
+];
+var CreateDataSourceFromS3 = [
+    9,
+    n0,
+    _CDSFS,
+    0,
+    () => CreateDataSourceFromS3Input,
+    () => CreateDataSourceFromS3Output,
+];
+var CreateEvaluation = [
+    9,
+    n0,
+    _CE,
+    0,
+    () => CreateEvaluationInput,
+    () => CreateEvaluationOutput,
+];
+var CreateMLModel = [
+    9,
+    n0,
+    _CMLM,
+    0,
+    () => CreateMLModelInput,
+    () => CreateMLModelOutput,
+];
+var CreateRealtimeEndpoint = [
+    9,
+    n0,
+    _CRE,
+    0,
+    () => CreateRealtimeEndpointInput,
+    () => CreateRealtimeEndpointOutput,
+];
+var DeleteBatchPrediction = [
+    9,
+    n0,
+    _DBP,
+    0,
+    () => DeleteBatchPredictionInput,
+    () => DeleteBatchPredictionOutput,
+];
+var DeleteDataSource = [
+    9,
+    n0,
+    _DDS,
+    0,
+    () => DeleteDataSourceInput,
+    () => DeleteDataSourceOutput,
+];
+var DeleteEvaluation = [
+    9,
+    n0,
+    _DE,
+    0,
+    () => DeleteEvaluationInput,
+    () => DeleteEvaluationOutput,
+];
+var DeleteMLModel = [
+    9,
+    n0,
+    _DMLM,
+    0,
+    () => DeleteMLModelInput,
+    () => DeleteMLModelOutput,
+];
+var DeleteRealtimeEndpoint = [
+    9,
+    n0,
+    _DRE,
+    0,
+    () => DeleteRealtimeEndpointInput,
+    () => DeleteRealtimeEndpointOutput,
+];
+var DeleteTags = [9, n0, _DT, 0, () => DeleteTagsInput, () => DeleteTagsOutput];
+var DescribeBatchPredictions = [
+    9,
+    n0,
+    _DBPe,
+    0,
+    () => DescribeBatchPredictionsInput,
+    () => DescribeBatchPredictionsOutput,
+];
+var DescribeDataSources = [
+    9,
+    n0,
+    _DDSe,
+    0,
+    () => DescribeDataSourcesInput,
+    () => DescribeDataSourcesOutput,
+];
+var DescribeEvaluations = [
+    9,
+    n0,
+    _DEe,
+    0,
+    () => DescribeEvaluationsInput,
+    () => DescribeEvaluationsOutput,
+];
+var DescribeMLModels = [
+    9,
+    n0,
+    _DMLMe,
+    0,
+    () => DescribeMLModelsInput,
+    () => DescribeMLModelsOutput,
+];
+var DescribeTags = [9, n0, _DTe, 0, () => DescribeTagsInput, () => DescribeTagsOutput];
+var GetBatchPrediction = [
+    9,
+    n0,
+    _GBP,
+    0,
+    () => GetBatchPredictionInput,
+    () => GetBatchPredictionOutput,
+];
+var GetDataSource = [9, n0, _GDS, 0, () => GetDataSourceInput, () => GetDataSourceOutput];
+var GetEvaluation = [9, n0, _GEe, 0, () => GetEvaluationInput, () => GetEvaluationOutput];
+var GetMLModel = [9, n0, _GMLM, 0, () => GetMLModelInput, () => GetMLModelOutput];
+var Predict = [9, n0, _Pred, 0, () => PredictInput, () => PredictOutput];
+var UpdateBatchPrediction = [
+    9,
+    n0,
+    _UBP,
+    0,
+    () => UpdateBatchPredictionInput,
+    () => UpdateBatchPredictionOutput,
+];
+var UpdateDataSource = [
+    9,
+    n0,
+    _UDS,
+    0,
+    () => UpdateDataSourceInput,
+    () => UpdateDataSourceOutput,
+];
+var UpdateEvaluation = [
+    9,
+    n0,
+    _UE,
+    0,
+    () => UpdateEvaluationInput,
+    () => UpdateEvaluationOutput,
+];
+var UpdateMLModel = [
+    9,
+    n0,
+    _UMLM,
+    0,
+    () => UpdateMLModelInput,
+    () => UpdateMLModelOutput,
+];
 
 class AddTagsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "AddTags", {})
     .n("MachineLearningClient", "AddTagsCommand")
-    .f(void 0, void 0)
-    .ser(se_AddTagsCommand)
-    .de(de_AddTagsCommand)
+    .sc(AddTags)
     .build() {
 }
 
@@ -1300,16 +1061,11 @@ class CreateBatchPredictionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "CreateBatchPrediction", {})
     .n("MachineLearningClient", "CreateBatchPredictionCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateBatchPredictionCommand)
-    .de(de_CreateBatchPredictionCommand)
+    .sc(CreateBatchPrediction)
     .build() {
 }
 
@@ -1317,16 +1073,11 @@ class CreateDataSourceFromRDSCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "CreateDataSourceFromRDS", {})
     .n("MachineLearningClient", "CreateDataSourceFromRDSCommand")
-    .f(CreateDataSourceFromRDSInputFilterSensitiveLog, void 0)
-    .ser(se_CreateDataSourceFromRDSCommand)
-    .de(de_CreateDataSourceFromRDSCommand)
+    .sc(CreateDataSourceFromRDS)
     .build() {
 }
 
@@ -1334,16 +1085,11 @@ class CreateDataSourceFromRedshiftCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "CreateDataSourceFromRedshift", {})
     .n("MachineLearningClient", "CreateDataSourceFromRedshiftCommand")
-    .f(CreateDataSourceFromRedshiftInputFilterSensitiveLog, void 0)
-    .ser(se_CreateDataSourceFromRedshiftCommand)
-    .de(de_CreateDataSourceFromRedshiftCommand)
+    .sc(CreateDataSourceFromRedshift)
     .build() {
 }
 
@@ -1351,16 +1097,11 @@ class CreateDataSourceFromS3Command extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "CreateDataSourceFromS3", {})
     .n("MachineLearningClient", "CreateDataSourceFromS3Command")
-    .f(void 0, void 0)
-    .ser(se_CreateDataSourceFromS3Command)
-    .de(de_CreateDataSourceFromS3Command)
+    .sc(CreateDataSourceFromS3)
     .build() {
 }
 
@@ -1368,16 +1109,11 @@ class CreateEvaluationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "CreateEvaluation", {})
     .n("MachineLearningClient", "CreateEvaluationCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateEvaluationCommand)
-    .de(de_CreateEvaluationCommand)
+    .sc(CreateEvaluation)
     .build() {
 }
 
@@ -1385,16 +1121,11 @@ class CreateMLModelCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "CreateMLModel", {})
     .n("MachineLearningClient", "CreateMLModelCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateMLModelCommand)
-    .de(de_CreateMLModelCommand)
+    .sc(CreateMLModel)
     .build() {
 }
 
@@ -1402,16 +1133,11 @@ class CreateRealtimeEndpointCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "CreateRealtimeEndpoint", {})
     .n("MachineLearningClient", "CreateRealtimeEndpointCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateRealtimeEndpointCommand)
-    .de(de_CreateRealtimeEndpointCommand)
+    .sc(CreateRealtimeEndpoint)
     .build() {
 }
 
@@ -1419,16 +1145,11 @@ class DeleteBatchPredictionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "DeleteBatchPrediction", {})
     .n("MachineLearningClient", "DeleteBatchPredictionCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteBatchPredictionCommand)
-    .de(de_DeleteBatchPredictionCommand)
+    .sc(DeleteBatchPrediction)
     .build() {
 }
 
@@ -1436,16 +1157,11 @@ class DeleteDataSourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "DeleteDataSource", {})
     .n("MachineLearningClient", "DeleteDataSourceCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDataSourceCommand)
-    .de(de_DeleteDataSourceCommand)
+    .sc(DeleteDataSource)
     .build() {
 }
 
@@ -1453,16 +1169,11 @@ class DeleteEvaluationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "DeleteEvaluation", {})
     .n("MachineLearningClient", "DeleteEvaluationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteEvaluationCommand)
-    .de(de_DeleteEvaluationCommand)
+    .sc(DeleteEvaluation)
     .build() {
 }
 
@@ -1470,16 +1181,11 @@ class DeleteMLModelCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "DeleteMLModel", {})
     .n("MachineLearningClient", "DeleteMLModelCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteMLModelCommand)
-    .de(de_DeleteMLModelCommand)
+    .sc(DeleteMLModel)
     .build() {
 }
 
@@ -1487,16 +1193,11 @@ class DeleteRealtimeEndpointCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "DeleteRealtimeEndpoint", {})
     .n("MachineLearningClient", "DeleteRealtimeEndpointCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteRealtimeEndpointCommand)
-    .de(de_DeleteRealtimeEndpointCommand)
+    .sc(DeleteRealtimeEndpoint)
     .build() {
 }
 
@@ -1504,16 +1205,11 @@ class DeleteTagsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "DeleteTags", {})
     .n("MachineLearningClient", "DeleteTagsCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteTagsCommand)
-    .de(de_DeleteTagsCommand)
+    .sc(DeleteTags)
     .build() {
 }
 
@@ -1521,16 +1217,11 @@ class DescribeBatchPredictionsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "DescribeBatchPredictions", {})
     .n("MachineLearningClient", "DescribeBatchPredictionsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeBatchPredictionsCommand)
-    .de(de_DescribeBatchPredictionsCommand)
+    .sc(DescribeBatchPredictions)
     .build() {
 }
 
@@ -1538,16 +1229,11 @@ class DescribeDataSourcesCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "DescribeDataSources", {})
     .n("MachineLearningClient", "DescribeDataSourcesCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeDataSourcesCommand)
-    .de(de_DescribeDataSourcesCommand)
+    .sc(DescribeDataSources)
     .build() {
 }
 
@@ -1555,16 +1241,11 @@ class DescribeEvaluationsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "DescribeEvaluations", {})
     .n("MachineLearningClient", "DescribeEvaluationsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeEvaluationsCommand)
-    .de(de_DescribeEvaluationsCommand)
+    .sc(DescribeEvaluations)
     .build() {
 }
 
@@ -1572,16 +1253,11 @@ class DescribeMLModelsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "DescribeMLModels", {})
     .n("MachineLearningClient", "DescribeMLModelsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeMLModelsCommand)
-    .de(de_DescribeMLModelsCommand)
+    .sc(DescribeMLModels)
     .build() {
 }
 
@@ -1589,16 +1265,11 @@ class DescribeTagsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "DescribeTags", {})
     .n("MachineLearningClient", "DescribeTagsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeTagsCommand)
-    .de(de_DescribeTagsCommand)
+    .sc(DescribeTags)
     .build() {
 }
 
@@ -1606,16 +1277,11 @@ class GetBatchPredictionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "GetBatchPrediction", {})
     .n("MachineLearningClient", "GetBatchPredictionCommand")
-    .f(void 0, void 0)
-    .ser(se_GetBatchPredictionCommand)
-    .de(de_GetBatchPredictionCommand)
+    .sc(GetBatchPrediction)
     .build() {
 }
 
@@ -1623,16 +1289,11 @@ class GetDataSourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "GetDataSource", {})
     .n("MachineLearningClient", "GetDataSourceCommand")
-    .f(void 0, void 0)
-    .ser(se_GetDataSourceCommand)
-    .de(de_GetDataSourceCommand)
+    .sc(GetDataSource)
     .build() {
 }
 
@@ -1640,16 +1301,11 @@ class GetEvaluationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "GetEvaluation", {})
     .n("MachineLearningClient", "GetEvaluationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetEvaluationCommand)
-    .de(de_GetEvaluationCommand)
+    .sc(GetEvaluation)
     .build() {
 }
 
@@ -1657,16 +1313,11 @@ class GetMLModelCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "GetMLModel", {})
     .n("MachineLearningClient", "GetMLModelCommand")
-    .f(void 0, void 0)
-    .ser(se_GetMLModelCommand)
-    .de(de_GetMLModelCommand)
+    .sc(GetMLModel)
     .build() {
 }
 
@@ -1674,17 +1325,11 @@ class PredictCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-        middlewareSdkMachinelearning.getPredictEndpointPlugin(config),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()), middlewareSdkMachinelearning.getPredictEndpointPlugin(config)];
 })
     .s("AmazonML_20141212", "Predict", {})
     .n("MachineLearningClient", "PredictCommand")
-    .f(void 0, void 0)
-    .ser(se_PredictCommand)
-    .de(de_PredictCommand)
+    .sc(Predict)
     .build() {
 }
 
@@ -1692,16 +1337,11 @@ class UpdateBatchPredictionCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "UpdateBatchPrediction", {})
     .n("MachineLearningClient", "UpdateBatchPredictionCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateBatchPredictionCommand)
-    .de(de_UpdateBatchPredictionCommand)
+    .sc(UpdateBatchPrediction)
     .build() {
 }
 
@@ -1709,16 +1349,11 @@ class UpdateDataSourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "UpdateDataSource", {})
     .n("MachineLearningClient", "UpdateDataSourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateDataSourceCommand)
-    .de(de_UpdateDataSourceCommand)
+    .sc(UpdateDataSource)
     .build() {
 }
 
@@ -1726,16 +1361,11 @@ class UpdateEvaluationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "UpdateEvaluation", {})
     .n("MachineLearningClient", "UpdateEvaluationCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateEvaluationCommand)
-    .de(de_UpdateEvaluationCommand)
+    .sc(UpdateEvaluation)
     .build() {
 }
 
@@ -1743,16 +1373,11 @@ class UpdateMLModelCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AmazonML_20141212", "UpdateMLModel", {})
     .n("MachineLearningClient", "UpdateMLModelCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateMLModelCommand)
-    .de(de_UpdateMLModelCommand)
+    .sc(UpdateMLModel)
     .build() {
 }
 
@@ -2023,9 +1648,7 @@ exports.Algorithm = Algorithm;
 exports.BatchPredictionFilterVariable = BatchPredictionFilterVariable;
 exports.CreateBatchPredictionCommand = CreateBatchPredictionCommand;
 exports.CreateDataSourceFromRDSCommand = CreateDataSourceFromRDSCommand;
-exports.CreateDataSourceFromRDSInputFilterSensitiveLog = CreateDataSourceFromRDSInputFilterSensitiveLog;
 exports.CreateDataSourceFromRedshiftCommand = CreateDataSourceFromRedshiftCommand;
-exports.CreateDataSourceFromRedshiftInputFilterSensitiveLog = CreateDataSourceFromRedshiftInputFilterSensitiveLog;
 exports.CreateDataSourceFromS3Command = CreateDataSourceFromS3Command;
 exports.CreateEvaluationCommand = CreateEvaluationCommand;
 exports.CreateMLModelCommand = CreateMLModelCommand;
@@ -2049,26 +1672,22 @@ exports.GetBatchPredictionCommand = GetBatchPredictionCommand;
 exports.GetDataSourceCommand = GetDataSourceCommand;
 exports.GetEvaluationCommand = GetEvaluationCommand;
 exports.GetMLModelCommand = GetMLModelCommand;
-exports.IdempotentParameterMismatchException = IdempotentParameterMismatchException;
-exports.InternalServerException = InternalServerException;
-exports.InvalidInputException = InvalidInputException;
-exports.InvalidTagException = InvalidTagException;
-exports.LimitExceededException = LimitExceededException;
+exports.IdempotentParameterMismatchException = IdempotentParameterMismatchException$1;
+exports.InternalServerException = InternalServerException$1;
+exports.InvalidInputException = InvalidInputException$1;
+exports.InvalidTagException = InvalidTagException$1;
+exports.LimitExceededException = LimitExceededException$1;
 exports.MLModelFilterVariable = MLModelFilterVariable;
 exports.MLModelType = MLModelType;
 exports.MachineLearning = MachineLearning;
 exports.MachineLearningClient = MachineLearningClient;
-exports.MachineLearningServiceException = MachineLearningServiceException;
+exports.MachineLearningServiceException = MachineLearningServiceException$1;
 exports.PredictCommand = PredictCommand;
-exports.PredictorNotMountedException = PredictorNotMountedException;
-exports.RDSDataSpecFilterSensitiveLog = RDSDataSpecFilterSensitiveLog;
-exports.RDSDatabaseCredentialsFilterSensitiveLog = RDSDatabaseCredentialsFilterSensitiveLog;
+exports.PredictorNotMountedException = PredictorNotMountedException$1;
 exports.RealtimeEndpointStatus = RealtimeEndpointStatus;
-exports.RedshiftDataSpecFilterSensitiveLog = RedshiftDataSpecFilterSensitiveLog;
-exports.RedshiftDatabaseCredentialsFilterSensitiveLog = RedshiftDatabaseCredentialsFilterSensitiveLog;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.SortOrder = SortOrder;
-exports.TagLimitExceededException = TagLimitExceededException;
+exports.TagLimitExceededException = TagLimitExceededException$1;
 exports.TaggableResourceType = TaggableResourceType;
 exports.UpdateBatchPredictionCommand = UpdateBatchPredictionCommand;
 exports.UpdateDataSourceCommand = UpdateDataSourceCommand;