@aws-sdk/client-machine-learning 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,13 +1,2980 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MachineLearningServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./MachineLearningClient"), exports);
-tslib_1.__exportStar(require("./MachineLearning"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./waiters"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var MachineLearningServiceException_1 = require("./models/MachineLearningServiceException");
-Object.defineProperty(exports, "MachineLearningServiceException", { enumerable: true, get: function () { return MachineLearningServiceException_1.MachineLearningServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AddTagsCommand: () => AddTagsCommand,
+  Algorithm: () => Algorithm,
+  BatchPredictionFilterVariable: () => BatchPredictionFilterVariable,
+  CreateBatchPredictionCommand: () => CreateBatchPredictionCommand,
+  CreateDataSourceFromRDSCommand: () => CreateDataSourceFromRDSCommand,
+  CreateDataSourceFromRDSInputFilterSensitiveLog: () => CreateDataSourceFromRDSInputFilterSensitiveLog,
+  CreateDataSourceFromRedshiftCommand: () => CreateDataSourceFromRedshiftCommand,
+  CreateDataSourceFromRedshiftInputFilterSensitiveLog: () => CreateDataSourceFromRedshiftInputFilterSensitiveLog,
+  CreateDataSourceFromS3Command: () => CreateDataSourceFromS3Command,
+  CreateEvaluationCommand: () => CreateEvaluationCommand,
+  CreateMLModelCommand: () => CreateMLModelCommand,
+  CreateRealtimeEndpointCommand: () => CreateRealtimeEndpointCommand,
+  DataSourceFilterVariable: () => DataSourceFilterVariable,
+  DeleteBatchPredictionCommand: () => DeleteBatchPredictionCommand,
+  DeleteDataSourceCommand: () => DeleteDataSourceCommand,
+  DeleteEvaluationCommand: () => DeleteEvaluationCommand,
+  DeleteMLModelCommand: () => DeleteMLModelCommand,
+  DeleteRealtimeEndpointCommand: () => DeleteRealtimeEndpointCommand,
+  DeleteTagsCommand: () => DeleteTagsCommand,
+  DescribeBatchPredictionsCommand: () => DescribeBatchPredictionsCommand,
+  DescribeDataSourcesCommand: () => DescribeDataSourcesCommand,
+  DescribeEvaluationsCommand: () => DescribeEvaluationsCommand,
+  DescribeMLModelsCommand: () => DescribeMLModelsCommand,
+  DescribeTagsCommand: () => DescribeTagsCommand,
+  DetailsAttributes: () => DetailsAttributes,
+  EntityStatus: () => EntityStatus,
+  EvaluationFilterVariable: () => EvaluationFilterVariable,
+  GetBatchPredictionCommand: () => GetBatchPredictionCommand,
+  GetDataSourceCommand: () => GetDataSourceCommand,
+  GetEvaluationCommand: () => GetEvaluationCommand,
+  GetMLModelCommand: () => GetMLModelCommand,
+  IdempotentParameterMismatchException: () => IdempotentParameterMismatchException,
+  InternalServerException: () => InternalServerException,
+  InvalidInputException: () => InvalidInputException,
+  InvalidTagException: () => InvalidTagException,
+  LimitExceededException: () => LimitExceededException,
+  MLModelFilterVariable: () => MLModelFilterVariable,
+  MLModelType: () => MLModelType,
+  MachineLearning: () => MachineLearning,
+  MachineLearningClient: () => MachineLearningClient,
+  MachineLearningServiceException: () => MachineLearningServiceException,
+  PredictCommand: () => PredictCommand,
+  PredictorNotMountedException: () => PredictorNotMountedException,
+  RDSDataSpecFilterSensitiveLog: () => RDSDataSpecFilterSensitiveLog,
+  RDSDatabaseCredentialsFilterSensitiveLog: () => RDSDatabaseCredentialsFilterSensitiveLog,
+  RealtimeEndpointStatus: () => RealtimeEndpointStatus,
+  RedshiftDataSpecFilterSensitiveLog: () => RedshiftDataSpecFilterSensitiveLog,
+  RedshiftDatabaseCredentialsFilterSensitiveLog: () => RedshiftDatabaseCredentialsFilterSensitiveLog,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  SortOrder: () => SortOrder,
+  TagLimitExceededException: () => TagLimitExceededException,
+  TaggableResourceType: () => TaggableResourceType,
+  UpdateBatchPredictionCommand: () => UpdateBatchPredictionCommand,
+  UpdateDataSourceCommand: () => UpdateDataSourceCommand,
+  UpdateEvaluationCommand: () => UpdateEvaluationCommand,
+  UpdateMLModelCommand: () => UpdateMLModelCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeBatchPredictions: () => paginateDescribeBatchPredictions,
+  paginateDescribeDataSources: () => paginateDescribeDataSources,
+  paginateDescribeEvaluations: () => paginateDescribeEvaluations,
+  paginateDescribeMLModels: () => paginateDescribeMLModels,
+  waitForBatchPredictionAvailable: () => waitForBatchPredictionAvailable,
+  waitForDataSourceAvailable: () => waitForDataSourceAvailable,
+  waitForEvaluationAvailable: () => waitForEvaluationAvailable,
+  waitForMLModelAvailable: () => waitForMLModelAvailable,
+  waitUntilBatchPredictionAvailable: () => waitUntilBatchPredictionAvailable,
+  waitUntilDataSourceAvailable: () => waitUntilDataSourceAvailable,
+  waitUntilEvaluationAvailable: () => waitUntilEvaluationAvailable,
+  waitUntilMLModelAvailable: () => waitUntilMLModelAvailable
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/MachineLearningClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_core = require("@smithy/core");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "machinelearning"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/MachineLearningClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+
+// src/auth/httpAuthExtensionConfiguration.ts
+var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
+  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+  let _credentials = runtimeConfig.credentials;
+  return {
+    setHttpAuthScheme(httpAuthScheme) {
+      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+      if (index === -1) {
+        _httpAuthSchemes.push(httpAuthScheme);
+      } else {
+        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+      }
+    },
+    httpAuthSchemes() {
+      return _httpAuthSchemes;
+    },
+    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+      _httpAuthSchemeProvider = httpAuthSchemeProvider;
+    },
+    httpAuthSchemeProvider() {
+      return _httpAuthSchemeProvider;
+    },
+    setCredentials(credentials) {
+      _credentials = credentials;
+    },
+    credentials() {
+      return _credentials;
+    }
+  };
+}, "getHttpAuthExtensionConfiguration");
+var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
+  return {
+    httpAuthSchemes: config.httpAuthSchemes(),
+    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+    credentials: config.credentials()
+  };
+}, "resolveHttpAuthRuntimeConfig");
+
+// src/runtimeExtensions.ts
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig)),
+    ...asPartial(getHttpAuthExtensionConfiguration(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
+    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/MachineLearningClient.ts
+var _MachineLearningClient = class _MachineLearningClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_5);
+    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+    this.middlewareStack.use(
+      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
+        httpAuthSchemeParametersProvider: this.getDefaultHttpAuthSchemeParametersProvider(),
+        identityProviderConfigProvider: this.getIdentityProviderConfigProvider()
+      })
+    );
+    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+  getDefaultHttpAuthSchemeParametersProvider() {
+    return import_httpAuthSchemeProvider.defaultMachineLearningHttpAuthSchemeParametersProvider;
+  }
+  getIdentityProviderConfigProvider() {
+    return async (config) => new import_core.DefaultIdentityProviderConfig({
+      "aws.auth#sigv4": config.credentials
+    });
+  }
+};
+__name(_MachineLearningClient, "MachineLearningClient");
+var MachineLearningClient = _MachineLearningClient;
+
+// src/MachineLearning.ts
+
+
+// src/commands/AddTagsCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/MachineLearningServiceException.ts
+
+var _MachineLearningServiceException = class _MachineLearningServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _MachineLearningServiceException.prototype);
+  }
+};
+__name(_MachineLearningServiceException, "MachineLearningServiceException");
+var MachineLearningServiceException = _MachineLearningServiceException;
+
+// src/models/models_0.ts
+
+var TaggableResourceType = {
+  BATCH_PREDICTION: "BatchPrediction",
+  DATASOURCE: "DataSource",
+  EVALUATION: "Evaluation",
+  ML_MODEL: "MLModel"
+};
+var _InternalServerException = class _InternalServerException extends MachineLearningServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+    this.code = opts.code;
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _InvalidInputException = class _InvalidInputException extends MachineLearningServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidInputException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidInputException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidInputException.prototype);
+    this.code = opts.code;
+  }
+};
+__name(_InvalidInputException, "InvalidInputException");
+var InvalidInputException = _InvalidInputException;
+var _InvalidTagException = class _InvalidTagException extends MachineLearningServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidTagException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidTagException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidTagException.prototype);
+  }
+};
+__name(_InvalidTagException, "InvalidTagException");
+var InvalidTagException = _InvalidTagException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends MachineLearningServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.code = opts.code;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _TagLimitExceededException = class _TagLimitExceededException extends MachineLearningServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TagLimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TagLimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TagLimitExceededException.prototype);
+  }
+};
+__name(_TagLimitExceededException, "TagLimitExceededException");
+var TagLimitExceededException = _TagLimitExceededException;
+var Algorithm = {
+  SGD: "sgd"
+};
+var _IdempotentParameterMismatchException = class _IdempotentParameterMismatchException extends MachineLearningServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "IdempotentParameterMismatchException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "IdempotentParameterMismatchException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _IdempotentParameterMismatchException.prototype);
+    this.code = opts.code;
+  }
+};
+__name(_IdempotentParameterMismatchException, "IdempotentParameterMismatchException");
+var IdempotentParameterMismatchException = _IdempotentParameterMismatchException;
+var MLModelType = {
+  BINARY: "BINARY",
+  MULTICLASS: "MULTICLASS",
+  REGRESSION: "REGRESSION"
+};
+var RealtimeEndpointStatus = {
+  FAILED: "FAILED",
+  NONE: "NONE",
+  READY: "READY",
+  UPDATING: "UPDATING"
+};
+var BatchPredictionFilterVariable = {
+  CREATED_AT: "CreatedAt",
+  DATASOURCE_ID: "DataSourceId",
+  DATA_URI: "DataURI",
+  IAM_USER: "IAMUser",
+  LAST_UPDATED_AT: "LastUpdatedAt",
+  ML_MODEL_ID: "MLModelId",
+  NAME: "Name",
+  STATUS: "Status"
+};
+var SortOrder = {
+  ASC: "asc",
+  DSC: "dsc"
+};
+var EntityStatus = {
+  COMPLETED: "COMPLETED",
+  DELETED: "DELETED",
+  FAILED: "FAILED",
+  INPROGRESS: "INPROGRESS",
+  PENDING: "PENDING"
+};
+var DataSourceFilterVariable = {
+  CREATED_AT: "CreatedAt",
+  DATA_URI: "DataLocationS3",
+  IAM_USER: "IAMUser",
+  LAST_UPDATED_AT: "LastUpdatedAt",
+  NAME: "Name",
+  STATUS: "Status"
+};
+var EvaluationFilterVariable = {
+  CREATED_AT: "CreatedAt",
+  DATASOURCE_ID: "DataSourceId",
+  DATA_URI: "DataURI",
+  IAM_USER: "IAMUser",
+  LAST_UPDATED_AT: "LastUpdatedAt",
+  ML_MODEL_ID: "MLModelId",
+  NAME: "Name",
+  STATUS: "Status"
+};
+var MLModelFilterVariable = {
+  ALGORITHM: "Algorithm",
+  CREATED_AT: "CreatedAt",
+  IAM_USER: "IAMUser",
+  LAST_UPDATED_AT: "LastUpdatedAt",
+  ML_MODEL_TYPE: "MLModelType",
+  NAME: "Name",
+  REAL_TIME_ENDPOINT_STATUS: "RealtimeEndpointStatus",
+  STATUS: "Status",
+  TRAINING_DATASOURCE_ID: "TrainingDataSourceId",
+  TRAINING_DATA_URI: "TrainingDataURI"
+};
+var _LimitExceededException = class _LimitExceededException extends MachineLearningServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+    this.code = opts.code;
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var _PredictorNotMountedException = class _PredictorNotMountedException extends MachineLearningServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PredictorNotMountedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PredictorNotMountedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PredictorNotMountedException.prototype);
+  }
+};
+__name(_PredictorNotMountedException, "PredictorNotMountedException");
+var PredictorNotMountedException = _PredictorNotMountedException;
+var DetailsAttributes = {
+  ALGORITHM: "Algorithm",
+  PREDICTIVE_MODEL_TYPE: "PredictiveModelType"
+};
+var RDSDatabaseCredentialsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Password && { Password: import_smithy_client.SENSITIVE_STRING }
+}), "RDSDatabaseCredentialsFilterSensitiveLog");
+var RDSDataSpecFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.DatabaseCredentials && {
+    DatabaseCredentials: RDSDatabaseCredentialsFilterSensitiveLog(obj.DatabaseCredentials)
+  }
+}), "RDSDataSpecFilterSensitiveLog");
+var CreateDataSourceFromRDSInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.RDSData && { RDSData: RDSDataSpecFilterSensitiveLog(obj.RDSData) }
+}), "CreateDataSourceFromRDSInputFilterSensitiveLog");
+var RedshiftDatabaseCredentialsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.Password && { Password: import_smithy_client.SENSITIVE_STRING }
+}), "RedshiftDatabaseCredentialsFilterSensitiveLog");
+var RedshiftDataSpecFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.DatabaseCredentials && {
+    DatabaseCredentials: RedshiftDatabaseCredentialsFilterSensitiveLog(obj.DatabaseCredentials)
+  }
+}), "RedshiftDataSpecFilterSensitiveLog");
+var CreateDataSourceFromRedshiftInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.DataSpec && { DataSpec: RedshiftDataSpecFilterSensitiveLog(obj.DataSpec) }
+}), "CreateDataSourceFromRedshiftInputFilterSensitiveLog");
+
+// src/protocols/Aws_json1_1.ts
+var se_AddTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AddTags");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AddTagsCommand");
+var se_CreateBatchPredictionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateBatchPrediction");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateBatchPredictionCommand");
+var se_CreateDataSourceFromRDSCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateDataSourceFromRDS");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateDataSourceFromRDSCommand");
+var se_CreateDataSourceFromRedshiftCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateDataSourceFromRedshift");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateDataSourceFromRedshiftCommand");
+var se_CreateDataSourceFromS3Command = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateDataSourceFromS3");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateDataSourceFromS3Command");
+var se_CreateEvaluationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateEvaluation");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateEvaluationCommand");
+var se_CreateMLModelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateMLModel");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateMLModelCommand");
+var se_CreateRealtimeEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateRealtimeEndpoint");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateRealtimeEndpointCommand");
+var se_DeleteBatchPredictionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteBatchPrediction");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteBatchPredictionCommand");
+var se_DeleteDataSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteDataSource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteDataSourceCommand");
+var se_DeleteEvaluationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteEvaluation");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteEvaluationCommand");
+var se_DeleteMLModelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteMLModel");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteMLModelCommand");
+var se_DeleteRealtimeEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteRealtimeEndpoint");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteRealtimeEndpointCommand");
+var se_DeleteTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteTags");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteTagsCommand");
+var se_DescribeBatchPredictionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeBatchPredictions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeBatchPredictionsCommand");
+var se_DescribeDataSourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeDataSources");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeDataSourcesCommand");
+var se_DescribeEvaluationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeEvaluations");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeEvaluationsCommand");
+var se_DescribeMLModelsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeMLModels");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeMLModelsCommand");
+var se_DescribeTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeTags");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeTagsCommand");
+var se_GetBatchPredictionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetBatchPrediction");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetBatchPredictionCommand");
+var se_GetDataSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetDataSource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetDataSourceCommand");
+var se_GetEvaluationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetEvaluation");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetEvaluationCommand");
+var se_GetMLModelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("GetMLModel");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_GetMLModelCommand");
+var se_PredictCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("Predict");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PredictCommand");
+var se_UpdateBatchPredictionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateBatchPrediction");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateBatchPredictionCommand");
+var se_UpdateDataSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateDataSource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateDataSourceCommand");
+var se_UpdateEvaluationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateEvaluation");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateEvaluationCommand");
+var se_UpdateMLModelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateMLModel");
+  let body;
+  body = JSON.stringify(se_UpdateMLModelInput(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateMLModelCommand");
+var de_AddTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AddTagsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AddTagsCommand");
+var de_AddTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "InvalidTagException":
+    case "com.amazonaws.machinelearning#InvalidTagException":
+      throw await de_InvalidTagExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "TagLimitExceededException":
+    case "com.amazonaws.machinelearning#TagLimitExceededException":
+      throw await de_TagLimitExceededExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddTagsCommandError");
+var de_CreateBatchPredictionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateBatchPredictionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateBatchPredictionCommand");
+var de_CreateBatchPredictionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateBatchPredictionCommandError");
+var de_CreateDataSourceFromRDSCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateDataSourceFromRDSCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateDataSourceFromRDSCommand");
+var de_CreateDataSourceFromRDSCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateDataSourceFromRDSCommandError");
+var de_CreateDataSourceFromRedshiftCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateDataSourceFromRedshiftCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateDataSourceFromRedshiftCommand");
+var de_CreateDataSourceFromRedshiftCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateDataSourceFromRedshiftCommandError");
+var de_CreateDataSourceFromS3Command = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateDataSourceFromS3CommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateDataSourceFromS3Command");
+var de_CreateDataSourceFromS3CommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateDataSourceFromS3CommandError");
+var de_CreateEvaluationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateEvaluationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateEvaluationCommand");
+var de_CreateEvaluationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateEvaluationCommandError");
+var de_CreateMLModelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateMLModelCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateMLModelCommand");
+var de_CreateMLModelCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "IdempotentParameterMismatchException":
+    case "com.amazonaws.machinelearning#IdempotentParameterMismatchException":
+      throw await de_IdempotentParameterMismatchExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateMLModelCommandError");
+var de_CreateRealtimeEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateRealtimeEndpointCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateRealtimeEndpointOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateRealtimeEndpointCommand");
+var de_CreateRealtimeEndpointCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateRealtimeEndpointCommandError");
+var de_DeleteBatchPredictionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteBatchPredictionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteBatchPredictionCommand");
+var de_DeleteBatchPredictionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteBatchPredictionCommandError");
+var de_DeleteDataSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteDataSourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteDataSourceCommand");
+var de_DeleteDataSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteDataSourceCommandError");
+var de_DeleteEvaluationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteEvaluationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteEvaluationCommand");
+var de_DeleteEvaluationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteEvaluationCommandError");
+var de_DeleteMLModelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteMLModelCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteMLModelCommand");
+var de_DeleteMLModelCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteMLModelCommandError");
+var de_DeleteRealtimeEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteRealtimeEndpointCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteRealtimeEndpointOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteRealtimeEndpointCommand");
+var de_DeleteRealtimeEndpointCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteRealtimeEndpointCommandError");
+var de_DeleteTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteTagsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteTagsCommand");
+var de_DeleteTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "InvalidTagException":
+    case "com.amazonaws.machinelearning#InvalidTagException":
+      throw await de_InvalidTagExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteTagsCommandError");
+var de_DescribeBatchPredictionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeBatchPredictionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeBatchPredictionsOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeBatchPredictionsCommand");
+var de_DescribeBatchPredictionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeBatchPredictionsCommandError");
+var de_DescribeDataSourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeDataSourcesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeDataSourcesOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeDataSourcesCommand");
+var de_DescribeDataSourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeDataSourcesCommandError");
+var de_DescribeEvaluationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEvaluationsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeEvaluationsOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeEvaluationsCommand");
+var de_DescribeEvaluationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeEvaluationsCommandError");
+var de_DescribeMLModelsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeMLModelsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeMLModelsOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeMLModelsCommand");
+var de_DescribeMLModelsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeMLModelsCommandError");
+var de_DescribeTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeTagsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeTagsCommand");
+var de_DescribeTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeTagsCommandError");
+var de_GetBatchPredictionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetBatchPredictionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetBatchPredictionOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetBatchPredictionCommand");
+var de_GetBatchPredictionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetBatchPredictionCommandError");
+var de_GetDataSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetDataSourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetDataSourceOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetDataSourceCommand");
+var de_GetDataSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetDataSourceCommandError");
+var de_GetEvaluationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetEvaluationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetEvaluationOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetEvaluationCommand");
+var de_GetEvaluationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetEvaluationCommandError");
+var de_GetMLModelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_GetMLModelCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_GetMLModelOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_GetMLModelCommand");
+var de_GetMLModelCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetMLModelCommandError");
+var de_PredictCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PredictCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_PredictOutput(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PredictCommand");
+var de_PredictCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.machinelearning#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "PredictorNotMountedException":
+    case "com.amazonaws.machinelearning#PredictorNotMountedException":
+      throw await de_PredictorNotMountedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PredictCommandError");
+var de_UpdateBatchPredictionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateBatchPredictionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateBatchPredictionCommand");
+var de_UpdateBatchPredictionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateBatchPredictionCommandError");
+var de_UpdateDataSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateDataSourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateDataSourceCommand");
+var de_UpdateDataSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateDataSourceCommandError");
+var de_UpdateEvaluationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateEvaluationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateEvaluationCommand");
+var de_UpdateEvaluationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateEvaluationCommandError");
+var de_UpdateMLModelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateMLModelCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateMLModelCommand");
+var de_UpdateMLModelCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.machinelearning#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "InvalidInputException":
+    case "com.amazonaws.machinelearning#InvalidInputException":
+      throw await de_InvalidInputExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.machinelearning#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateMLModelCommandError");
+var de_IdempotentParameterMismatchExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new IdempotentParameterMismatchException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_IdempotentParameterMismatchExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalServerExceptionRes");
+var de_InvalidInputExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidInputException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidInputExceptionRes");
+var de_InvalidTagExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidTagException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidTagExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LimitExceededExceptionRes");
+var de_PredictorNotMountedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new PredictorNotMountedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_PredictorNotMountedExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_TagLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TagLimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TagLimitExceededExceptionRes");
+var se_UpdateMLModelInput = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    MLModelId: [],
+    MLModelName: [],
+    ScoreThreshold: import_smithy_client.serializeFloat
+  });
+}, "se_UpdateMLModelInput");
+var de_BatchPrediction = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BatchPredictionDataSourceId: import_smithy_client.expectString,
+    BatchPredictionId: import_smithy_client.expectString,
+    ComputeTime: import_smithy_client.expectLong,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreatedByIamUser: import_smithy_client.expectString,
+    FinishedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    InputDataLocationS3: import_smithy_client.expectString,
+    InvalidRecordCount: import_smithy_client.expectLong,
+    LastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    MLModelId: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    OutputUri: import_smithy_client.expectString,
+    StartedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString,
+    TotalRecordCount: import_smithy_client.expectLong
+  });
+}, "de_BatchPrediction");
+var de_BatchPredictions = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_BatchPrediction(entry, context);
+  });
+  return retVal;
+}, "de_BatchPredictions");
+var de_CreateRealtimeEndpointOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MLModelId: import_smithy_client.expectString,
+    RealtimeEndpointInfo: (_) => de_RealtimeEndpointInfo(_, context)
+  });
+}, "de_CreateRealtimeEndpointOutput");
+var de_DataSource = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ComputeStatistics: import_smithy_client.expectBoolean,
+    ComputeTime: import_smithy_client.expectLong,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreatedByIamUser: import_smithy_client.expectString,
+    DataLocationS3: import_smithy_client.expectString,
+    DataRearrangement: import_smithy_client.expectString,
+    DataSizeInBytes: import_smithy_client.expectLong,
+    DataSourceId: import_smithy_client.expectString,
+    FinishedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Message: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    NumberOfFiles: import_smithy_client.expectLong,
+    RDSMetadata: import_smithy_client._json,
+    RedshiftMetadata: import_smithy_client._json,
+    RoleARN: import_smithy_client.expectString,
+    StartedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString
+  });
+}, "de_DataSource");
+var de_DataSources = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_DataSource(entry, context);
+  });
+  return retVal;
+}, "de_DataSources");
+var de_DeleteRealtimeEndpointOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    MLModelId: import_smithy_client.expectString,
+    RealtimeEndpointInfo: (_) => de_RealtimeEndpointInfo(_, context)
+  });
+}, "de_DeleteRealtimeEndpointOutput");
+var de_DescribeBatchPredictionsOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    Results: (_) => de_BatchPredictions(_, context)
+  });
+}, "de_DescribeBatchPredictionsOutput");
+var de_DescribeDataSourcesOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    Results: (_) => de_DataSources(_, context)
+  });
+}, "de_DescribeDataSourcesOutput");
+var de_DescribeEvaluationsOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    Results: (_) => de_Evaluations(_, context)
+  });
+}, "de_DescribeEvaluationsOutput");
+var de_DescribeMLModelsOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    NextToken: import_smithy_client.expectString,
+    Results: (_) => de_MLModels(_, context)
+  });
+}, "de_DescribeMLModelsOutput");
+var de_Evaluation = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ComputeTime: import_smithy_client.expectLong,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreatedByIamUser: import_smithy_client.expectString,
+    EvaluationDataSourceId: import_smithy_client.expectString,
+    EvaluationId: import_smithy_client.expectString,
+    FinishedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    InputDataLocationS3: import_smithy_client.expectString,
+    LastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    MLModelId: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    PerformanceMetrics: import_smithy_client._json,
+    StartedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString
+  });
+}, "de_Evaluation");
+var de_Evaluations = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Evaluation(entry, context);
+  });
+  return retVal;
+}, "de_Evaluations");
+var de_GetBatchPredictionOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    BatchPredictionDataSourceId: import_smithy_client.expectString,
+    BatchPredictionId: import_smithy_client.expectString,
+    ComputeTime: import_smithy_client.expectLong,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreatedByIamUser: import_smithy_client.expectString,
+    FinishedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    InputDataLocationS3: import_smithy_client.expectString,
+    InvalidRecordCount: import_smithy_client.expectLong,
+    LastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LogUri: import_smithy_client.expectString,
+    MLModelId: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    OutputUri: import_smithy_client.expectString,
+    StartedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString,
+    TotalRecordCount: import_smithy_client.expectLong
+  });
+}, "de_GetBatchPredictionOutput");
+var de_GetDataSourceOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ComputeStatistics: import_smithy_client.expectBoolean,
+    ComputeTime: import_smithy_client.expectLong,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreatedByIamUser: import_smithy_client.expectString,
+    DataLocationS3: import_smithy_client.expectString,
+    DataRearrangement: import_smithy_client.expectString,
+    DataSizeInBytes: import_smithy_client.expectLong,
+    DataSourceId: import_smithy_client.expectString,
+    DataSourceSchema: import_smithy_client.expectString,
+    FinishedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LogUri: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    NumberOfFiles: import_smithy_client.expectLong,
+    RDSMetadata: import_smithy_client._json,
+    RedshiftMetadata: import_smithy_client._json,
+    RoleARN: import_smithy_client.expectString,
+    StartedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString
+  });
+}, "de_GetDataSourceOutput");
+var de_GetEvaluationOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ComputeTime: import_smithy_client.expectLong,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreatedByIamUser: import_smithy_client.expectString,
+    EvaluationDataSourceId: import_smithy_client.expectString,
+    EvaluationId: import_smithy_client.expectString,
+    FinishedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    InputDataLocationS3: import_smithy_client.expectString,
+    LastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LogUri: import_smithy_client.expectString,
+    MLModelId: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    PerformanceMetrics: import_smithy_client._json,
+    StartedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString
+  });
+}, "de_GetEvaluationOutput");
+var de_GetMLModelOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ComputeTime: import_smithy_client.expectLong,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreatedByIamUser: import_smithy_client.expectString,
+    EndpointInfo: (_) => de_RealtimeEndpointInfo(_, context),
+    FinishedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    InputDataLocationS3: import_smithy_client.expectString,
+    LastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    LogUri: import_smithy_client.expectString,
+    MLModelId: import_smithy_client.expectString,
+    MLModelType: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    Recipe: import_smithy_client.expectString,
+    Schema: import_smithy_client.expectString,
+    ScoreThreshold: import_smithy_client.limitedParseFloat32,
+    ScoreThresholdLastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    SizeInBytes: import_smithy_client.expectLong,
+    StartedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString,
+    TrainingDataSourceId: import_smithy_client.expectString,
+    TrainingParameters: import_smithy_client._json
+  });
+}, "de_GetMLModelOutput");
+var de_MLModel = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Algorithm: import_smithy_client.expectString,
+    ComputeTime: import_smithy_client.expectLong,
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    CreatedByIamUser: import_smithy_client.expectString,
+    EndpointInfo: (_) => de_RealtimeEndpointInfo(_, context),
+    FinishedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    InputDataLocationS3: import_smithy_client.expectString,
+    LastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    MLModelId: import_smithy_client.expectString,
+    MLModelType: import_smithy_client.expectString,
+    Message: import_smithy_client.expectString,
+    Name: import_smithy_client.expectString,
+    ScoreThreshold: import_smithy_client.limitedParseFloat32,
+    ScoreThresholdLastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    SizeInBytes: import_smithy_client.expectLong,
+    StartedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Status: import_smithy_client.expectString,
+    TrainingDataSourceId: import_smithy_client.expectString,
+    TrainingParameters: import_smithy_client._json
+  });
+}, "de_MLModel");
+var de_MLModels = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MLModel(entry, context);
+  });
+  return retVal;
+}, "de_MLModels");
+var de_Prediction = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    details: import_smithy_client._json,
+    predictedLabel: import_smithy_client.expectString,
+    predictedScores: (_) => de_ScoreValuePerLabelMap(_, context),
+    predictedValue: import_smithy_client.limitedParseFloat32
+  });
+}, "de_Prediction");
+var de_PredictOutput = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Prediction: (_) => de_Prediction(_, context)
+  });
+}, "de_PredictOutput");
+var de_RealtimeEndpointInfo = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CreatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    EndpointStatus: import_smithy_client.expectString,
+    EndpointUrl: import_smithy_client.expectString,
+    PeakRequestsPerSecond: import_smithy_client.expectInt32
+  });
+}, "de_RealtimeEndpointInfo");
+var de_ScoreValuePerLabelMap = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = (0, import_smithy_client.limitedParseFloat32)(value);
+    return acc;
+  }, {});
+}, "de_ScoreValuePerLabelMap");
+var deserializeMetadata = /* @__PURE__ */ __name((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"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(MachineLearningServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(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 (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `AmazonML_20141212.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/AddTagsCommand.ts
+var _AddTagsCommand = class _AddTagsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "AddTags", {}).n("MachineLearningClient", "AddTagsCommand").f(void 0, void 0).ser(se_AddTagsCommand).de(de_AddTagsCommand).build() {
+};
+__name(_AddTagsCommand, "AddTagsCommand");
+var AddTagsCommand = _AddTagsCommand;
+
+// src/commands/CreateBatchPredictionCommand.ts
+
+
+
+
+var _CreateBatchPredictionCommand = class _CreateBatchPredictionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "CreateBatchPrediction", {}).n("MachineLearningClient", "CreateBatchPredictionCommand").f(void 0, void 0).ser(se_CreateBatchPredictionCommand).de(de_CreateBatchPredictionCommand).build() {
+};
+__name(_CreateBatchPredictionCommand, "CreateBatchPredictionCommand");
+var CreateBatchPredictionCommand = _CreateBatchPredictionCommand;
+
+// src/commands/CreateDataSourceFromRDSCommand.ts
+
+
+
+
+var _CreateDataSourceFromRDSCommand = class _CreateDataSourceFromRDSCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "CreateDataSourceFromRDS", {}).n("MachineLearningClient", "CreateDataSourceFromRDSCommand").f(CreateDataSourceFromRDSInputFilterSensitiveLog, void 0).ser(se_CreateDataSourceFromRDSCommand).de(de_CreateDataSourceFromRDSCommand).build() {
+};
+__name(_CreateDataSourceFromRDSCommand, "CreateDataSourceFromRDSCommand");
+var CreateDataSourceFromRDSCommand = _CreateDataSourceFromRDSCommand;
+
+// src/commands/CreateDataSourceFromRedshiftCommand.ts
+
+
+
+
+var _CreateDataSourceFromRedshiftCommand = class _CreateDataSourceFromRedshiftCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "CreateDataSourceFromRedshift", {}).n("MachineLearningClient", "CreateDataSourceFromRedshiftCommand").f(CreateDataSourceFromRedshiftInputFilterSensitiveLog, void 0).ser(se_CreateDataSourceFromRedshiftCommand).de(de_CreateDataSourceFromRedshiftCommand).build() {
+};
+__name(_CreateDataSourceFromRedshiftCommand, "CreateDataSourceFromRedshiftCommand");
+var CreateDataSourceFromRedshiftCommand = _CreateDataSourceFromRedshiftCommand;
+
+// src/commands/CreateDataSourceFromS3Command.ts
+
+
+
+
+var _CreateDataSourceFromS3Command = class _CreateDataSourceFromS3Command extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "CreateDataSourceFromS3", {}).n("MachineLearningClient", "CreateDataSourceFromS3Command").f(void 0, void 0).ser(se_CreateDataSourceFromS3Command).de(de_CreateDataSourceFromS3Command).build() {
+};
+__name(_CreateDataSourceFromS3Command, "CreateDataSourceFromS3Command");
+var CreateDataSourceFromS3Command = _CreateDataSourceFromS3Command;
+
+// src/commands/CreateEvaluationCommand.ts
+
+
+
+
+var _CreateEvaluationCommand = class _CreateEvaluationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "CreateEvaluation", {}).n("MachineLearningClient", "CreateEvaluationCommand").f(void 0, void 0).ser(se_CreateEvaluationCommand).de(de_CreateEvaluationCommand).build() {
+};
+__name(_CreateEvaluationCommand, "CreateEvaluationCommand");
+var CreateEvaluationCommand = _CreateEvaluationCommand;
+
+// src/commands/CreateMLModelCommand.ts
+
+
+
+
+var _CreateMLModelCommand = class _CreateMLModelCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "CreateMLModel", {}).n("MachineLearningClient", "CreateMLModelCommand").f(void 0, void 0).ser(se_CreateMLModelCommand).de(de_CreateMLModelCommand).build() {
+};
+__name(_CreateMLModelCommand, "CreateMLModelCommand");
+var CreateMLModelCommand = _CreateMLModelCommand;
+
+// src/commands/CreateRealtimeEndpointCommand.ts
+
+
+
+
+var _CreateRealtimeEndpointCommand = class _CreateRealtimeEndpointCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "CreateRealtimeEndpoint", {}).n("MachineLearningClient", "CreateRealtimeEndpointCommand").f(void 0, void 0).ser(se_CreateRealtimeEndpointCommand).de(de_CreateRealtimeEndpointCommand).build() {
+};
+__name(_CreateRealtimeEndpointCommand, "CreateRealtimeEndpointCommand");
+var CreateRealtimeEndpointCommand = _CreateRealtimeEndpointCommand;
+
+// src/commands/DeleteBatchPredictionCommand.ts
+
+
+
+
+var _DeleteBatchPredictionCommand = class _DeleteBatchPredictionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "DeleteBatchPrediction", {}).n("MachineLearningClient", "DeleteBatchPredictionCommand").f(void 0, void 0).ser(se_DeleteBatchPredictionCommand).de(de_DeleteBatchPredictionCommand).build() {
+};
+__name(_DeleteBatchPredictionCommand, "DeleteBatchPredictionCommand");
+var DeleteBatchPredictionCommand = _DeleteBatchPredictionCommand;
+
+// src/commands/DeleteDataSourceCommand.ts
+
+
+
+
+var _DeleteDataSourceCommand = class _DeleteDataSourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "DeleteDataSource", {}).n("MachineLearningClient", "DeleteDataSourceCommand").f(void 0, void 0).ser(se_DeleteDataSourceCommand).de(de_DeleteDataSourceCommand).build() {
+};
+__name(_DeleteDataSourceCommand, "DeleteDataSourceCommand");
+var DeleteDataSourceCommand = _DeleteDataSourceCommand;
+
+// src/commands/DeleteEvaluationCommand.ts
+
+
+
+
+var _DeleteEvaluationCommand = class _DeleteEvaluationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "DeleteEvaluation", {}).n("MachineLearningClient", "DeleteEvaluationCommand").f(void 0, void 0).ser(se_DeleteEvaluationCommand).de(de_DeleteEvaluationCommand).build() {
+};
+__name(_DeleteEvaluationCommand, "DeleteEvaluationCommand");
+var DeleteEvaluationCommand = _DeleteEvaluationCommand;
+
+// src/commands/DeleteMLModelCommand.ts
+
+
+
+
+var _DeleteMLModelCommand = class _DeleteMLModelCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "DeleteMLModel", {}).n("MachineLearningClient", "DeleteMLModelCommand").f(void 0, void 0).ser(se_DeleteMLModelCommand).de(de_DeleteMLModelCommand).build() {
+};
+__name(_DeleteMLModelCommand, "DeleteMLModelCommand");
+var DeleteMLModelCommand = _DeleteMLModelCommand;
+
+// src/commands/DeleteRealtimeEndpointCommand.ts
+
+
+
+
+var _DeleteRealtimeEndpointCommand = class _DeleteRealtimeEndpointCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "DeleteRealtimeEndpoint", {}).n("MachineLearningClient", "DeleteRealtimeEndpointCommand").f(void 0, void 0).ser(se_DeleteRealtimeEndpointCommand).de(de_DeleteRealtimeEndpointCommand).build() {
+};
+__name(_DeleteRealtimeEndpointCommand, "DeleteRealtimeEndpointCommand");
+var DeleteRealtimeEndpointCommand = _DeleteRealtimeEndpointCommand;
+
+// src/commands/DeleteTagsCommand.ts
+
+
+
+
+var _DeleteTagsCommand = class _DeleteTagsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "DeleteTags", {}).n("MachineLearningClient", "DeleteTagsCommand").f(void 0, void 0).ser(se_DeleteTagsCommand).de(de_DeleteTagsCommand).build() {
+};
+__name(_DeleteTagsCommand, "DeleteTagsCommand");
+var DeleteTagsCommand = _DeleteTagsCommand;
+
+// src/commands/DescribeBatchPredictionsCommand.ts
+
+
+
+
+var _DescribeBatchPredictionsCommand = class _DescribeBatchPredictionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "DescribeBatchPredictions", {}).n("MachineLearningClient", "DescribeBatchPredictionsCommand").f(void 0, void 0).ser(se_DescribeBatchPredictionsCommand).de(de_DescribeBatchPredictionsCommand).build() {
+};
+__name(_DescribeBatchPredictionsCommand, "DescribeBatchPredictionsCommand");
+var DescribeBatchPredictionsCommand = _DescribeBatchPredictionsCommand;
+
+// src/commands/DescribeDataSourcesCommand.ts
+
+
+
+
+var _DescribeDataSourcesCommand = class _DescribeDataSourcesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "DescribeDataSources", {}).n("MachineLearningClient", "DescribeDataSourcesCommand").f(void 0, void 0).ser(se_DescribeDataSourcesCommand).de(de_DescribeDataSourcesCommand).build() {
+};
+__name(_DescribeDataSourcesCommand, "DescribeDataSourcesCommand");
+var DescribeDataSourcesCommand = _DescribeDataSourcesCommand;
+
+// src/commands/DescribeEvaluationsCommand.ts
+
+
+
+
+var _DescribeEvaluationsCommand = class _DescribeEvaluationsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "DescribeEvaluations", {}).n("MachineLearningClient", "DescribeEvaluationsCommand").f(void 0, void 0).ser(se_DescribeEvaluationsCommand).de(de_DescribeEvaluationsCommand).build() {
+};
+__name(_DescribeEvaluationsCommand, "DescribeEvaluationsCommand");
+var DescribeEvaluationsCommand = _DescribeEvaluationsCommand;
+
+// src/commands/DescribeMLModelsCommand.ts
+
+
+
+
+var _DescribeMLModelsCommand = class _DescribeMLModelsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "DescribeMLModels", {}).n("MachineLearningClient", "DescribeMLModelsCommand").f(void 0, void 0).ser(se_DescribeMLModelsCommand).de(de_DescribeMLModelsCommand).build() {
+};
+__name(_DescribeMLModelsCommand, "DescribeMLModelsCommand");
+var DescribeMLModelsCommand = _DescribeMLModelsCommand;
+
+// src/commands/DescribeTagsCommand.ts
+
+
+
+
+var _DescribeTagsCommand = class _DescribeTagsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "DescribeTags", {}).n("MachineLearningClient", "DescribeTagsCommand").f(void 0, void 0).ser(se_DescribeTagsCommand).de(de_DescribeTagsCommand).build() {
+};
+__name(_DescribeTagsCommand, "DescribeTagsCommand");
+var DescribeTagsCommand = _DescribeTagsCommand;
+
+// src/commands/GetBatchPredictionCommand.ts
+
+
+
+
+var _GetBatchPredictionCommand = class _GetBatchPredictionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "GetBatchPrediction", {}).n("MachineLearningClient", "GetBatchPredictionCommand").f(void 0, void 0).ser(se_GetBatchPredictionCommand).de(de_GetBatchPredictionCommand).build() {
+};
+__name(_GetBatchPredictionCommand, "GetBatchPredictionCommand");
+var GetBatchPredictionCommand = _GetBatchPredictionCommand;
+
+// src/commands/GetDataSourceCommand.ts
+
+
+
+
+var _GetDataSourceCommand = class _GetDataSourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "GetDataSource", {}).n("MachineLearningClient", "GetDataSourceCommand").f(void 0, void 0).ser(se_GetDataSourceCommand).de(de_GetDataSourceCommand).build() {
+};
+__name(_GetDataSourceCommand, "GetDataSourceCommand");
+var GetDataSourceCommand = _GetDataSourceCommand;
+
+// src/commands/GetEvaluationCommand.ts
+
+
+
+
+var _GetEvaluationCommand = class _GetEvaluationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "GetEvaluation", {}).n("MachineLearningClient", "GetEvaluationCommand").f(void 0, void 0).ser(se_GetEvaluationCommand).de(de_GetEvaluationCommand).build() {
+};
+__name(_GetEvaluationCommand, "GetEvaluationCommand");
+var GetEvaluationCommand = _GetEvaluationCommand;
+
+// src/commands/GetMLModelCommand.ts
+
+
+
+
+var _GetMLModelCommand = class _GetMLModelCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "GetMLModel", {}).n("MachineLearningClient", "GetMLModelCommand").f(void 0, void 0).ser(se_GetMLModelCommand).de(de_GetMLModelCommand).build() {
+};
+__name(_GetMLModelCommand, "GetMLModelCommand");
+var GetMLModelCommand = _GetMLModelCommand;
+
+// src/commands/PredictCommand.ts
+var import_middleware_sdk_machinelearning = require("@aws-sdk/middleware-sdk-machinelearning");
+
+
+
+
+var _PredictCommand = class _PredictCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions()),
+    (0, import_middleware_sdk_machinelearning.getPredictEndpointPlugin)(config)
+  ];
+}).s("AmazonML_20141212", "Predict", {}).n("MachineLearningClient", "PredictCommand").f(void 0, void 0).ser(se_PredictCommand).de(de_PredictCommand).build() {
+};
+__name(_PredictCommand, "PredictCommand");
+var PredictCommand = _PredictCommand;
+
+// src/commands/UpdateBatchPredictionCommand.ts
+
+
+
+
+var _UpdateBatchPredictionCommand = class _UpdateBatchPredictionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "UpdateBatchPrediction", {}).n("MachineLearningClient", "UpdateBatchPredictionCommand").f(void 0, void 0).ser(se_UpdateBatchPredictionCommand).de(de_UpdateBatchPredictionCommand).build() {
+};
+__name(_UpdateBatchPredictionCommand, "UpdateBatchPredictionCommand");
+var UpdateBatchPredictionCommand = _UpdateBatchPredictionCommand;
+
+// src/commands/UpdateDataSourceCommand.ts
+
+
+
+
+var _UpdateDataSourceCommand = class _UpdateDataSourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "UpdateDataSource", {}).n("MachineLearningClient", "UpdateDataSourceCommand").f(void 0, void 0).ser(se_UpdateDataSourceCommand).de(de_UpdateDataSourceCommand).build() {
+};
+__name(_UpdateDataSourceCommand, "UpdateDataSourceCommand");
+var UpdateDataSourceCommand = _UpdateDataSourceCommand;
+
+// src/commands/UpdateEvaluationCommand.ts
+
+
+
+
+var _UpdateEvaluationCommand = class _UpdateEvaluationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "UpdateEvaluation", {}).n("MachineLearningClient", "UpdateEvaluationCommand").f(void 0, void 0).ser(se_UpdateEvaluationCommand).de(de_UpdateEvaluationCommand).build() {
+};
+__name(_UpdateEvaluationCommand, "UpdateEvaluationCommand");
+var UpdateEvaluationCommand = _UpdateEvaluationCommand;
+
+// src/commands/UpdateMLModelCommand.ts
+
+
+
+
+var _UpdateMLModelCommand = class _UpdateMLModelCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonML_20141212", "UpdateMLModel", {}).n("MachineLearningClient", "UpdateMLModelCommand").f(void 0, void 0).ser(se_UpdateMLModelCommand).de(de_UpdateMLModelCommand).build() {
+};
+__name(_UpdateMLModelCommand, "UpdateMLModelCommand");
+var UpdateMLModelCommand = _UpdateMLModelCommand;
+
+// src/MachineLearning.ts
+var commands = {
+  AddTagsCommand,
+  CreateBatchPredictionCommand,
+  CreateDataSourceFromRDSCommand,
+  CreateDataSourceFromRedshiftCommand,
+  CreateDataSourceFromS3Command,
+  CreateEvaluationCommand,
+  CreateMLModelCommand,
+  CreateRealtimeEndpointCommand,
+  DeleteBatchPredictionCommand,
+  DeleteDataSourceCommand,
+  DeleteEvaluationCommand,
+  DeleteMLModelCommand,
+  DeleteRealtimeEndpointCommand,
+  DeleteTagsCommand,
+  DescribeBatchPredictionsCommand,
+  DescribeDataSourcesCommand,
+  DescribeEvaluationsCommand,
+  DescribeMLModelsCommand,
+  DescribeTagsCommand,
+  GetBatchPredictionCommand,
+  GetDataSourceCommand,
+  GetEvaluationCommand,
+  GetMLModelCommand,
+  PredictCommand,
+  UpdateBatchPredictionCommand,
+  UpdateDataSourceCommand,
+  UpdateEvaluationCommand,
+  UpdateMLModelCommand
+};
+var _MachineLearning = class _MachineLearning extends MachineLearningClient {
+};
+__name(_MachineLearning, "MachineLearning");
+var MachineLearning = _MachineLearning;
+(0, import_smithy_client.createAggregatedClient)(commands, MachineLearning);
+
+// src/pagination/DescribeBatchPredictionsPaginator.ts
+
+var paginateDescribeBatchPredictions = (0, import_core.createPaginator)(MachineLearningClient, DescribeBatchPredictionsCommand, "NextToken", "NextToken", "Limit");
+
+// src/pagination/DescribeDataSourcesPaginator.ts
+
+var paginateDescribeDataSources = (0, import_core.createPaginator)(MachineLearningClient, DescribeDataSourcesCommand, "NextToken", "NextToken", "Limit");
+
+// src/pagination/DescribeEvaluationsPaginator.ts
+
+var paginateDescribeEvaluations = (0, import_core.createPaginator)(MachineLearningClient, DescribeEvaluationsCommand, "NextToken", "NextToken", "Limit");
+
+// src/pagination/DescribeMLModelsPaginator.ts
+
+var paginateDescribeMLModels = (0, import_core.createPaginator)(MachineLearningClient, DescribeMLModelsCommand, "NextToken", "NextToken", "Limit");
+
+// src/waiters/waitForBatchPredictionAvailable.ts
+var import_util_waiter = require("@smithy/util-waiter");
+var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeBatchPredictionsCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.Results);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.Status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "COMPLETED";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.Results);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.Status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "FAILED") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForBatchPredictionAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForBatchPredictionAvailable");
+var waitUntilBatchPredictionAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilBatchPredictionAvailable");
+
+// src/waiters/waitForDataSourceAvailable.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeDataSourcesCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.Results);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.Status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "COMPLETED";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.Results);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.Status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "FAILED") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForDataSourceAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "waitForDataSourceAvailable");
+var waitUntilDataSourceAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilDataSourceAvailable");
+
+// src/waiters/waitForEvaluationAvailable.ts
+
+var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeEvaluationsCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.Results);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.Status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "COMPLETED";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.Results);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.Status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "FAILED") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForEvaluationAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+}, "waitForEvaluationAvailable");
+var waitUntilEvaluationAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilEvaluationAvailable");
+
+// src/waiters/waitForMLModelAvailable.ts
+
+var checkState4 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeMLModelsCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.Results);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.Status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "COMPLETED";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.Results);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.Status;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "FAILED") {
+          return { state: import_util_waiter.WaiterState.FAILURE, reason };
+        }
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForMLModelAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
+}, "waitForMLModelAvailable");
+var waitUntilMLModelAvailable = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState4);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilMLModelAvailable");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddTagsCommand,
+  Algorithm,
+  BatchPredictionFilterVariable,
+  CreateBatchPredictionCommand,
+  CreateDataSourceFromRDSCommand,
+  CreateDataSourceFromRDSInputFilterSensitiveLog,
+  CreateDataSourceFromRedshiftCommand,
+  CreateDataSourceFromRedshiftInputFilterSensitiveLog,
+  CreateDataSourceFromS3Command,
+  CreateEvaluationCommand,
+  CreateMLModelCommand,
+  CreateRealtimeEndpointCommand,
+  DataSourceFilterVariable,
+  DeleteBatchPredictionCommand,
+  DeleteDataSourceCommand,
+  DeleteEvaluationCommand,
+  DeleteMLModelCommand,
+  DeleteRealtimeEndpointCommand,
+  DeleteTagsCommand,
+  DescribeBatchPredictionsCommand,
+  DescribeDataSourcesCommand,
+  DescribeEvaluationsCommand,
+  DescribeMLModelsCommand,
+  DescribeTagsCommand,
+  DetailsAttributes,
+  EntityStatus,
+  EvaluationFilterVariable,
+  GetBatchPredictionCommand,
+  GetDataSourceCommand,
+  GetEvaluationCommand,
+  GetMLModelCommand,
+  IdempotentParameterMismatchException,
+  InternalServerException,
+  InvalidInputException,
+  InvalidTagException,
+  LimitExceededException,
+  MLModelFilterVariable,
+  MLModelType,
+  MachineLearning,
+  MachineLearningClient,
+  MachineLearningServiceException,
+  PredictCommand,
+  PredictorNotMountedException,
+  RDSDataSpecFilterSensitiveLog,
+  RDSDatabaseCredentialsFilterSensitiveLog,
+  RealtimeEndpointStatus,
+  RedshiftDataSpecFilterSensitiveLog,
+  RedshiftDatabaseCredentialsFilterSensitiveLog,
+  ResourceNotFoundException,
+  SortOrder,
+  TagLimitExceededException,
+  TaggableResourceType,
+  UpdateBatchPredictionCommand,
+  UpdateDataSourceCommand,
+  UpdateEvaluationCommand,
+  UpdateMLModelCommand,
+  __Client,
+  paginateDescribeBatchPredictions,
+  paginateDescribeDataSources,
+  paginateDescribeEvaluations,
+  paginateDescribeMLModels,
+  waitForBatchPredictionAvailable,
+  waitForDataSourceAvailable,
+  waitForEvaluationAvailable,
+  waitForMLModelAvailable,
+  waitUntilBatchPredictionAvailable,
+  waitUntilDataSourceAvailable,
+  waitUntilEvaluationAvailable,
+  waitUntilMLModelAvailable
+});