@aws-sdk/client-machine-learning 3.34.0 → 3.37.0

package/commands/CreateDataSourceFromRedshiftCommand.ts

@@ -1,131 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { CreateDataSourceFromRedshiftInput, CreateDataSourceFromRedshiftOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_1CreateDataSourceFromRedshiftCommand,
-  serializeAws_json1_1CreateDataSourceFromRedshiftCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateDataSourceFromRedshiftCommandInput extends CreateDataSourceFromRedshiftInput {}
-export interface CreateDataSourceFromRedshiftCommandOutput
-  extends CreateDataSourceFromRedshiftOutput,
-    __MetadataBearer {}
-
-/**
- * <p>Creates a <code>DataSource</code> from a database hosted on an Amazon Redshift cluster. A
- * 		<code>DataSource</code> references data that can be used to perform either <code>CreateMLModel</code>, <code>CreateEvaluation</code>, or <code>CreateBatchPrediction</code>
- * 		operations.</p>
- *
- *         <p>
- *             <code>CreateDataSourceFromRedshift</code> is an asynchronous operation. In response to <code>CreateDataSourceFromRedshift</code>, Amazon Machine Learning (Amazon ML) immediately returns and sets the <code>DataSource</code> status to <code>PENDING</code>.
- *             After the <code>DataSource</code> is created and ready for use, Amazon ML sets the <code>Status</code> parameter to <code>COMPLETED</code>.
- *           <code>DataSource</code> in <code>COMPLETED</code> or <code>PENDING</code> states can be
- *           used to perform only <code>CreateMLModel</code>, <code>CreateEvaluation</code>, or <code>CreateBatchPrediction</code> operations.
- *         </p>
- *
- *         <p>
- *           If Amazon ML can't accept the input source, it sets the <code>Status</code> parameter to <code>FAILED</code> and includes an error message in the <code>Message</code>
- * 		  attribute of the <code>GetDataSource</code> operation response.
- *         </p>
- *
- *         <p>The observations should be contained in the database hosted on an Amazon Redshift cluster
- *             and should be specified by a <code>SelectSqlQuery</code> query. Amazon ML executes an
- *                 <code>Unload</code> command in Amazon Redshift to transfer the result set of
- *                 the <code>SelectSqlQuery</code> query to <code>S3StagingLocation</code>.</p>
- *
- *         <p>After the <code>DataSource</code> has been created, it's ready for use in evaluations and
- *             batch predictions. If you plan to use the <code>DataSource</code> to train an
- *                 <code>MLModel</code>, the <code>DataSource</code> also requires a recipe. A recipe
- *             describes how each input variable will be used in training an <code>MLModel</code>. Will
- *             the variable be included or excluded from training? Will the variable be manipulated;
- *             for example, will it be combined with another variable or will it be split apart into
- *             word combinations? The recipe provides answers to these questions.</p>
- *          <p>You can't change an existing datasource, but you can copy and modify the settings from an
- *             existing Amazon Redshift datasource to create a new datasource. To do so, call
- *                 <code>GetDataSource</code> for an existing datasource and copy the values to a
- *                 <code>CreateDataSource</code> call. Change the settings that you want to change and
- *             make sure that all required fields have the appropriate values.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, CreateDataSourceFromRedshiftCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, CreateDataSourceFromRedshiftCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new CreateDataSourceFromRedshiftCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDataSourceFromRedshiftCommandInput} for command's `input` shape.
- * @see {@link CreateDataSourceFromRedshiftCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateDataSourceFromRedshiftCommand extends $Command<
-  CreateDataSourceFromRedshiftCommandInput,
-  CreateDataSourceFromRedshiftCommandOutput,
-  MachineLearningClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateDataSourceFromRedshiftCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MachineLearningClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateDataSourceFromRedshiftCommandInput, CreateDataSourceFromRedshiftCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MachineLearningClient";
-    const commandName = "CreateDataSourceFromRedshiftCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateDataSourceFromRedshiftInput.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateDataSourceFromRedshiftOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateDataSourceFromRedshiftCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1CreateDataSourceFromRedshiftCommand(input, context);
-  }
-
-  private deserialize(
-    output: __HttpResponse,
-    context: __SerdeContext
-  ): Promise<CreateDataSourceFromRedshiftCommandOutput> {
-    return deserializeAws_json1_1CreateDataSourceFromRedshiftCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateDataSourceFromS3Command.ts

@@ -1,124 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { CreateDataSourceFromS3Input, CreateDataSourceFromS3Output } from "../models/models_0";
-import {
-  deserializeAws_json1_1CreateDataSourceFromS3Command,
-  serializeAws_json1_1CreateDataSourceFromS3Command,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateDataSourceFromS3CommandInput extends CreateDataSourceFromS3Input {}
-export interface CreateDataSourceFromS3CommandOutput extends CreateDataSourceFromS3Output, __MetadataBearer {}
-
-/**
- * <p>Creates a <code>DataSource</code> object. A <code>DataSource</code> references data that
- *           can be used to perform  <code>CreateMLModel</code>, <code>CreateEvaluation</code>, or
- *           <code>CreateBatchPrediction</code> operations.</p>
- *
- *         <p>
- *             <code>CreateDataSourceFromS3</code> is an asynchronous operation. In response to
- *                 <code>CreateDataSourceFromS3</code>, Amazon Machine Learning (Amazon ML) immediately
- *             returns and sets the <code>DataSource</code> status to <code>PENDING</code>. After the
- *                 <code>DataSource</code> has been created and is ready for use, Amazon ML sets the
- *                 <code>Status</code> parameter to <code>COMPLETED</code>. <code>DataSource</code> in
- *             the <code>COMPLETED</code> or <code>PENDING</code> state can be used to perform only
- *                 <code>CreateMLModel</code>, <code>CreateEvaluation</code> or
- *                 <code>CreateBatchPrediction</code> operations. </p>
- *
- *         <p> If Amazon ML can't accept the input source, it sets the <code>Status</code> parameter to
- *                 <code>FAILED</code> and includes an error message in the <code>Message</code>
- *             attribute of the <code>GetDataSource</code> operation response. </p>
- *
- *         <p>The observation data used in a <code>DataSource</code> should be ready to use; that is,
- *             it should have a consistent structure, and missing data values should be kept to a
- *             minimum. The observation data must reside in one or more .csv files in an Amazon Simple
- *             Storage Service (Amazon S3) location, along with a schema that describes the data items
- *             by name and type. The same schema must be used for all of the data files referenced by
- *             the <code>DataSource</code>. </p>
- *         <p>After the <code>DataSource</code> has been created, it's ready to use in evaluations and
- *             batch predictions. If you plan to use the <code>DataSource</code> to train an
- *                 <code>MLModel</code>, the <code>DataSource</code> also needs a recipe. A recipe
- *             describes how each input variable will be used in training an <code>MLModel</code>. Will
- *             the variable be included or excluded from training? Will the variable be manipulated;
- *             for example, will it be combined with another variable or will it be split apart into
- *             word combinations? The recipe provides answers to these questions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, CreateDataSourceFromS3Command } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, CreateDataSourceFromS3Command } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new CreateDataSourceFromS3Command(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDataSourceFromS3CommandInput} for command's `input` shape.
- * @see {@link CreateDataSourceFromS3CommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateDataSourceFromS3Command extends $Command<
-  CreateDataSourceFromS3CommandInput,
-  CreateDataSourceFromS3CommandOutput,
-  MachineLearningClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateDataSourceFromS3CommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MachineLearningClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateDataSourceFromS3CommandInput, CreateDataSourceFromS3CommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MachineLearningClient";
-    const commandName = "CreateDataSourceFromS3Command";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateDataSourceFromS3Input.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateDataSourceFromS3Output.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateDataSourceFromS3CommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1CreateDataSourceFromS3Command(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateDataSourceFromS3CommandOutput> {
-    return deserializeAws_json1_1CreateDataSourceFromS3Command(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateEvaluationCommand.ts

@@ -1,105 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { CreateEvaluationInput, CreateEvaluationOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_1CreateEvaluationCommand,
-  serializeAws_json1_1CreateEvaluationCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateEvaluationCommandInput extends CreateEvaluationInput {}
-export interface CreateEvaluationCommandOutput extends CreateEvaluationOutput, __MetadataBearer {}
-
-/**
- * <p>Creates a new <code>Evaluation</code> of an <code>MLModel</code>. An <code>MLModel</code> is evaluated on a set of observations associated to a <code>DataSource</code>. Like a <code>DataSource</code>
- *           for an <code>MLModel</code>, the <code>DataSource</code> for an <code>Evaluation</code> contains values for the <code>Target Variable</code>. The <code>Evaluation</code> compares the predicted result for each observation to the actual outcome and provides a
- *             summary so that you know how effective the <code>MLModel</code> functions on the test
- *           data. Evaluation generates a relevant performance metric, such as BinaryAUC, RegressionRMSE or MulticlassAvgFScore based on the corresponding <code>MLModelType</code>: <code>BINARY</code>, <code>REGRESSION</code> or <code>MULTICLASS</code>.
- *
- *         </p>
- *         <p>
- *             <code>CreateEvaluation</code> is an asynchronous operation. In response to <code>CreateEvaluation</code>, Amazon Machine Learning (Amazon ML) immediately
- *             returns and sets the evaluation status to <code>PENDING</code>. After the <code>Evaluation</code> is created and ready for use,
- *             Amazon ML sets the status to <code>COMPLETED</code>.
- *         </p>
- *         <p>You can use the <code>GetEvaluation</code> operation to check progress of the evaluation during the creation operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, CreateEvaluationCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, CreateEvaluationCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new CreateEvaluationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateEvaluationCommandInput} for command's `input` shape.
- * @see {@link CreateEvaluationCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateEvaluationCommand extends $Command<
-  CreateEvaluationCommandInput,
-  CreateEvaluationCommandOutput,
-  MachineLearningClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateEvaluationCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MachineLearningClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateEvaluationCommandInput, CreateEvaluationCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MachineLearningClient";
-    const commandName = "CreateEvaluationCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateEvaluationInput.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateEvaluationOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateEvaluationCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1CreateEvaluationCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateEvaluationCommandOutput> {
-    return deserializeAws_json1_1CreateEvaluationCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateMLModelCommand.ts

@@ -1,113 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { CreateMLModelInput, CreateMLModelOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_1CreateMLModelCommand,
-  serializeAws_json1_1CreateMLModelCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateMLModelCommandInput extends CreateMLModelInput {}
-export interface CreateMLModelCommandOutput extends CreateMLModelOutput, __MetadataBearer {}
-
-/**
- * <p>Creates a new <code>MLModel</code> using the <code>DataSource</code> and the recipe as
- *             information sources. </p>
- *         <p>An <code>MLModel</code> is nearly immutable. Users can update only the
- *                 <code>MLModelName</code> and the <code>ScoreThreshold</code> in an
- *                 <code>MLModel</code> without creating a new <code>MLModel</code>. </p>
- *         <p>
- *             <code>CreateMLModel</code> is an asynchronous operation. In response to
- *                 <code>CreateMLModel</code>, Amazon Machine Learning (Amazon ML) immediately returns
- *             and sets the <code>MLModel</code> status to <code>PENDING</code>. After the
- *                 <code>MLModel</code> has been created and ready is for use, Amazon ML sets the
- *             status to <code>COMPLETED</code>. </p>
- *         <p>You can use the <code>GetMLModel</code> operation to check the progress of the
- *                 <code>MLModel</code> during the creation operation.</p>
- *
- *         <p>
- *            <code>CreateMLModel</code> requires a <code>DataSource</code> with computed statistics,
- *           which can be created by setting <code>ComputeStatistics</code> to <code>true</code> in
- *           <code>CreateDataSourceFromRDS</code>, <code>CreateDataSourceFromS3</code>, or
- *           <code>CreateDataSourceFromRedshift</code> operations.
- *         </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, CreateMLModelCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, CreateMLModelCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new CreateMLModelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateMLModelCommandInput} for command's `input` shape.
- * @see {@link CreateMLModelCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateMLModelCommand extends $Command<
-  CreateMLModelCommandInput,
-  CreateMLModelCommandOutput,
-  MachineLearningClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateMLModelCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MachineLearningClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateMLModelCommandInput, CreateMLModelCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MachineLearningClient";
-    const commandName = "CreateMLModelCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateMLModelInput.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateMLModelOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateMLModelCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1CreateMLModelCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateMLModelCommandOutput> {
-    return deserializeAws_json1_1CreateMLModelCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/CreateRealtimeEndpointCommand.ts

@@ -1,94 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { CreateRealtimeEndpointInput, CreateRealtimeEndpointOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_1CreateRealtimeEndpointCommand,
-  serializeAws_json1_1CreateRealtimeEndpointCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface CreateRealtimeEndpointCommandInput extends CreateRealtimeEndpointInput {}
-export interface CreateRealtimeEndpointCommandOutput extends CreateRealtimeEndpointOutput, __MetadataBearer {}
-
-/**
- * <p>Creates a real-time endpoint for the <code>MLModel</code>. The endpoint contains the URI of the <code>MLModel</code>; that is, the location to send real-time prediction requests for the specified <code>MLModel</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, CreateRealtimeEndpointCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, CreateRealtimeEndpointCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new CreateRealtimeEndpointCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateRealtimeEndpointCommandInput} for command's `input` shape.
- * @see {@link CreateRealtimeEndpointCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class CreateRealtimeEndpointCommand extends $Command<
-  CreateRealtimeEndpointCommandInput,
-  CreateRealtimeEndpointCommandOutput,
-  MachineLearningClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: CreateRealtimeEndpointCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MachineLearningClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<CreateRealtimeEndpointCommandInput, CreateRealtimeEndpointCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MachineLearningClient";
-    const commandName = "CreateRealtimeEndpointCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: CreateRealtimeEndpointInput.filterSensitiveLog,
-      outputFilterSensitiveLog: CreateRealtimeEndpointOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: CreateRealtimeEndpointCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1CreateRealtimeEndpointCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<CreateRealtimeEndpointCommandOutput> {
-    return deserializeAws_json1_1CreateRealtimeEndpointCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}

package/commands/DeleteBatchPredictionCommand.ts

@@ -1,99 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { DeleteBatchPredictionInput, DeleteBatchPredictionOutput } from "../models/models_0";
-import {
-  deserializeAws_json1_1DeleteBatchPredictionCommand,
-  serializeAws_json1_1DeleteBatchPredictionCommand,
-} from "../protocols/Aws_json1_1";
-import { getSerdePlugin } from "@aws-sdk/middleware-serde";
-import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import {
-  FinalizeHandlerArguments,
-  Handler,
-  HandlerExecutionContext,
-  MiddlewareStack,
-  HttpHandlerOptions as __HttpHandlerOptions,
-  MetadataBearer as __MetadataBearer,
-  SerdeContext as __SerdeContext,
-} from "@aws-sdk/types";
-
-export interface DeleteBatchPredictionCommandInput extends DeleteBatchPredictionInput {}
-export interface DeleteBatchPredictionCommandOutput extends DeleteBatchPredictionOutput, __MetadataBearer {}
-
-/**
- * <p>Assigns the DELETED status to a <code>BatchPrediction</code>, rendering it unusable.</p>
- *         <p>After using the <code>DeleteBatchPrediction</code> operation, you can use the <a>GetBatchPrediction</a>
- *             operation to verify that the status of the <code>BatchPrediction</code> changed to DELETED.</p>
- *
- *         <p>
- *             <b>Caution:</b> The result of the <code>DeleteBatchPrediction</code> operation is irreversible.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, DeleteBatchPredictionCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, DeleteBatchPredictionCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new DeleteBatchPredictionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteBatchPredictionCommandInput} for command's `input` shape.
- * @see {@link DeleteBatchPredictionCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export class DeleteBatchPredictionCommand extends $Command<
-  DeleteBatchPredictionCommandInput,
-  DeleteBatchPredictionCommandOutput,
-  MachineLearningClientResolvedConfig
-> {
-  // Start section: command_properties
-  // End section: command_properties
-
-  constructor(readonly input: DeleteBatchPredictionCommandInput) {
-    // Start section: command_constructor
-    super();
-    // End section: command_constructor
-  }
-
-  /**
-   * @internal
-   */
-  resolveMiddleware(
-    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
-    configuration: MachineLearningClientResolvedConfig,
-    options?: __HttpHandlerOptions
-  ): Handler<DeleteBatchPredictionCommandInput, DeleteBatchPredictionCommandOutput> {
-    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-
-    const stack = clientStack.concat(this.middlewareStack);
-
-    const { logger } = configuration;
-    const clientName = "MachineLearningClient";
-    const commandName = "DeleteBatchPredictionCommand";
-    const handlerExecutionContext: HandlerExecutionContext = {
-      logger,
-      clientName,
-      commandName,
-      inputFilterSensitiveLog: DeleteBatchPredictionInput.filterSensitiveLog,
-      outputFilterSensitiveLog: DeleteBatchPredictionOutput.filterSensitiveLog,
-    };
-    const { requestHandler } = configuration;
-    return stack.resolve(
-      (request: FinalizeHandlerArguments<any>) =>
-        requestHandler.handle(request.request as __HttpRequest, options || {}),
-      handlerExecutionContext
-    );
-  }
-
-  private serialize(input: DeleteBatchPredictionCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
-    return serializeAws_json1_1DeleteBatchPredictionCommand(input, context);
-  }
-
-  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<DeleteBatchPredictionCommandOutput> {
-    return deserializeAws_json1_1DeleteBatchPredictionCommand(output, context);
-  }
-
-  // Start section: command_body_extra
-  // End section: command_body_extra
-}