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

package/dist/types/ts3.4/commands/CreateDataSourceFromS3Command.d.ts

@@ -1,65 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { CreateDataSourceFromS3Input, CreateDataSourceFromS3Output } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class CreateDataSourceFromS3Command extends $Command<CreateDataSourceFromS3CommandInput, CreateDataSourceFromS3CommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: CreateDataSourceFromS3CommandInput;
-    constructor(input: CreateDataSourceFromS3CommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDataSourceFromS3CommandInput, CreateDataSourceFromS3CommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateEvaluationCommand.d.ts

@@ -1,46 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { CreateEvaluationInput, CreateEvaluationOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class CreateEvaluationCommand extends $Command<CreateEvaluationCommandInput, CreateEvaluationCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: CreateEvaluationCommandInput;
-    constructor(input: CreateEvaluationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEvaluationCommandInput, CreateEvaluationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateMLModelCommand.d.ts

@@ -1,54 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { CreateMLModelInput, CreateMLModelOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class CreateMLModelCommand extends $Command<CreateMLModelCommandInput, CreateMLModelCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: CreateMLModelCommandInput;
-    constructor(input: CreateMLModelCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMLModelCommandInput, CreateMLModelCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateRealtimeEndpointCommand.d.ts

@@ -1,35 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { CreateRealtimeEndpointInput, CreateRealtimeEndpointOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class CreateRealtimeEndpointCommand extends $Command<CreateRealtimeEndpointCommandInput, CreateRealtimeEndpointCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: CreateRealtimeEndpointCommandInput;
-    constructor(input: CreateRealtimeEndpointCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateRealtimeEndpointCommandInput, CreateRealtimeEndpointCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteBatchPredictionCommand.d.ts

@@ -1,40 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { DeleteBatchPredictionInput, DeleteBatchPredictionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } 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 declare class DeleteBatchPredictionCommand extends $Command<DeleteBatchPredictionCommandInput, DeleteBatchPredictionCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: DeleteBatchPredictionCommandInput;
-    constructor(input: DeleteBatchPredictionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteBatchPredictionCommandInput, DeleteBatchPredictionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteDataSourceCommand.d.ts

@@ -1,38 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { DeleteDataSourceInput, DeleteDataSourceOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteDataSourceCommandInput extends DeleteDataSourceInput {
-}
-export interface DeleteDataSourceCommandOutput extends DeleteDataSourceOutput, __MetadataBearer {
-}
-/**
- * <p>Assigns the DELETED status to a <code>DataSource</code>, rendering it unusable.</p>
- *         <p>After using the <code>DeleteDataSource</code> operation, you can use the <a>GetDataSource</a> operation to verify that the status of the <code>DataSource</code> changed to DELETED.</p>
- *         <p>
- *             <b>Caution:</b> The results of the <code>DeleteDataSource</code> operation are irreversible.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, DeleteDataSourceCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, DeleteDataSourceCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new DeleteDataSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDataSourceCommandInput} for command's `input` shape.
- * @see {@link DeleteDataSourceCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteDataSourceCommand extends $Command<DeleteDataSourceCommandInput, DeleteDataSourceCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: DeleteDataSourceCommandInput;
-    constructor(input: DeleteDataSourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDataSourceCommandInput, DeleteDataSourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteEvaluationCommand.d.ts

@@ -1,40 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { DeleteEvaluationInput, DeleteEvaluationOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteEvaluationCommandInput extends DeleteEvaluationInput {
-}
-export interface DeleteEvaluationCommandOutput extends DeleteEvaluationOutput, __MetadataBearer {
-}
-/**
- * <p>Assigns the <code>DELETED</code> status to an <code>Evaluation</code>, rendering it unusable.</p>
- *
- *         <p>After invoking the <code>DeleteEvaluation</code> operation, you can use the
- *           <code>GetEvaluation</code> operation to verify that the status of the <code>Evaluation</code> changed to <code>DELETED</code>.</p>
- *         <p>
- *             <b>Caution:</b> The results of the <code>DeleteEvaluation</code> operation are irreversible.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, DeleteEvaluationCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, DeleteEvaluationCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new DeleteEvaluationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEvaluationCommandInput} for command's `input` shape.
- * @see {@link DeleteEvaluationCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteEvaluationCommand extends $Command<DeleteEvaluationCommandInput, DeleteEvaluationCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: DeleteEvaluationCommandInput;
-    constructor(input: DeleteEvaluationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEvaluationCommandInput, DeleteEvaluationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteMLModelCommand.d.ts

@@ -1,40 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { DeleteMLModelInput, DeleteMLModelOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteMLModelCommandInput extends DeleteMLModelInput {
-}
-export interface DeleteMLModelCommandOutput extends DeleteMLModelOutput, __MetadataBearer {
-}
-/**
- * <p>Assigns the <code>DELETED</code> status to an <code>MLModel</code>, rendering it unusable.</p>
- *         <p>After using the <code>DeleteMLModel</code> operation, you can use the
- *           <code>GetMLModel</code> operation to verify that the status of the <code>MLModel</code> changed to DELETED.</p>
- *
- *         <p>
- *             <b>Caution:</b> The result of the <code>DeleteMLModel</code> operation is irreversible.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, DeleteMLModelCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, DeleteMLModelCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new DeleteMLModelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteMLModelCommandInput} for command's `input` shape.
- * @see {@link DeleteMLModelCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteMLModelCommand extends $Command<DeleteMLModelCommandInput, DeleteMLModelCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: DeleteMLModelCommandInput;
-    constructor(input: DeleteMLModelCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteMLModelCommandInput, DeleteMLModelCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteTagsCommand.d.ts

@@ -1,36 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { DeleteTagsInput, DeleteTagsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteTagsCommandInput extends DeleteTagsInput {
-}
-export interface DeleteTagsCommandOutput extends DeleteTagsOutput, __MetadataBearer {
-}
-/**
- * <p>Deletes the specified tags associated with an ML object. After this operation is complete, you can't recover deleted tags.</p>
- * 		       <p>If you specify a tag that doesn't exist, Amazon ML ignores it.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, DeleteTagsCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, DeleteTagsCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new DeleteTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTagsCommandInput} for command's `input` shape.
- * @see {@link DeleteTagsCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteTagsCommand extends $Command<DeleteTagsCommandInput, DeleteTagsCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: DeleteTagsCommandInput;
-    constructor(input: DeleteTagsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTagsCommandInput, DeleteTagsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeBatchPredictionsCommand.d.ts

@@ -1,35 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { DescribeBatchPredictionsInput, DescribeBatchPredictionsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeBatchPredictionsCommandInput extends DescribeBatchPredictionsInput {
-}
-export interface DescribeBatchPredictionsCommandOutput extends DescribeBatchPredictionsOutput, __MetadataBearer {
-}
-/**
- * <p>Returns a list of <code>BatchPrediction</code> operations that match the search criteria in the request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, DescribeBatchPredictionsCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, DescribeBatchPredictionsCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new DescribeBatchPredictionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeBatchPredictionsCommandInput} for command's `input` shape.
- * @see {@link DescribeBatchPredictionsCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeBatchPredictionsCommand extends $Command<DescribeBatchPredictionsCommandInput, DescribeBatchPredictionsCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: DescribeBatchPredictionsCommandInput;
-    constructor(input: DescribeBatchPredictionsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeBatchPredictionsCommandInput, DescribeBatchPredictionsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeDataSourcesCommand.d.ts

@@ -1,35 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { DescribeDataSourcesInput, DescribeDataSourcesOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeDataSourcesCommandInput extends DescribeDataSourcesInput {
-}
-export interface DescribeDataSourcesCommandOutput extends DescribeDataSourcesOutput, __MetadataBearer {
-}
-/**
- * <p>Returns a list of <code>DataSource</code> that match the search criteria in the request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, DescribeDataSourcesCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, DescribeDataSourcesCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new DescribeDataSourcesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDataSourcesCommandInput} for command's `input` shape.
- * @see {@link DescribeDataSourcesCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeDataSourcesCommand extends $Command<DescribeDataSourcesCommandInput, DescribeDataSourcesCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: DescribeDataSourcesCommandInput;
-    constructor(input: DescribeDataSourcesCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDataSourcesCommandInput, DescribeDataSourcesCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeEvaluationsCommand.d.ts

@@ -1,35 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { DescribeEvaluationsInput, DescribeEvaluationsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeEvaluationsCommandInput extends DescribeEvaluationsInput {
-}
-export interface DescribeEvaluationsCommandOutput extends DescribeEvaluationsOutput, __MetadataBearer {
-}
-/**
- * <p>Returns a list of <code>DescribeEvaluations</code> that match the search criteria in the request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, DescribeEvaluationsCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, DescribeEvaluationsCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new DescribeEvaluationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEvaluationsCommandInput} for command's `input` shape.
- * @see {@link DescribeEvaluationsCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeEvaluationsCommand extends $Command<DescribeEvaluationsCommandInput, DescribeEvaluationsCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: DescribeEvaluationsCommandInput;
-    constructor(input: DescribeEvaluationsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEvaluationsCommandInput, DescribeEvaluationsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeMLModelsCommand.d.ts

@@ -1,35 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { DescribeMLModelsInput, DescribeMLModelsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeMLModelsCommandInput extends DescribeMLModelsInput {
-}
-export interface DescribeMLModelsCommandOutput extends DescribeMLModelsOutput, __MetadataBearer {
-}
-/**
- * <p>Returns a list of <code>MLModel</code> that match the search criteria in the request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, DescribeMLModelsCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, DescribeMLModelsCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new DescribeMLModelsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeMLModelsCommandInput} for command's `input` shape.
- * @see {@link DescribeMLModelsCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeMLModelsCommand extends $Command<DescribeMLModelsCommandInput, DescribeMLModelsCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: DescribeMLModelsCommandInput;
-    constructor(input: DescribeMLModelsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeMLModelsCommandInput, DescribeMLModelsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DescribeTagsCommand.d.ts

@@ -1,35 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { DescribeTagsInput, DescribeTagsOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DescribeTagsCommandInput extends DescribeTagsInput {
-}
-export interface DescribeTagsCommandOutput extends DescribeTagsOutput, __MetadataBearer {
-}
-/**
- * <p>Describes one or more of the tags for your Amazon ML object.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, DescribeTagsCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, DescribeTagsCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new DescribeTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeTagsCommandInput} for command's `input` shape.
- * @see {@link DescribeTagsCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DescribeTagsCommand extends $Command<DescribeTagsCommandInput, DescribeTagsCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: DescribeTagsCommandInput;
-    constructor(input: DescribeTagsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeTagsCommandInput, DescribeTagsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetBatchPredictionCommand.d.ts

@@ -1,36 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { GetBatchPredictionInput, GetBatchPredictionOutput } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetBatchPredictionCommandInput extends GetBatchPredictionInput {
-}
-export interface GetBatchPredictionCommandOutput extends GetBatchPredictionOutput, __MetadataBearer {
-}
-/**
- * <p>Returns a <code>BatchPrediction</code> that includes detailed metadata, status, and data file information for a
- *             <code>Batch Prediction</code> request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, GetBatchPredictionCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, GetBatchPredictionCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new GetBatchPredictionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetBatchPredictionCommandInput} for command's `input` shape.
- * @see {@link GetBatchPredictionCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetBatchPredictionCommand extends $Command<GetBatchPredictionCommandInput, GetBatchPredictionCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: GetBatchPredictionCommandInput;
-    constructor(input: GetBatchPredictionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBatchPredictionCommandInput, GetBatchPredictionCommandOutput>;
-    private serialize;
-    private deserialize;
-}