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

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

@@ -1,38 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { GetDataSourceInput, GetDataSourceOutput } 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 GetDataSourceCommandInput extends GetDataSourceInput {
-}
-export interface GetDataSourceCommandOutput extends GetDataSourceOutput, __MetadataBearer {
-}
-/**
- * <p>Returns a <code>DataSource</code> that includes metadata and data file information, as well as the current status of the <code>DataSource</code>.</p>
- *         <p>
- *             <code>GetDataSource</code> provides results in normal or verbose format. The verbose format
- *             adds the schema description and the list of files pointed to by the DataSource to the normal format.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, GetDataSourceCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, GetDataSourceCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new GetDataSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDataSourceCommandInput} for command's `input` shape.
- * @see {@link GetDataSourceCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetDataSourceCommand extends $Command<GetDataSourceCommandInput, GetDataSourceCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: GetDataSourceCommandInput;
-    constructor(input: GetDataSourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDataSourceCommandInput, GetDataSourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,35 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { GetEvaluationInput, GetEvaluationOutput } 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 GetEvaluationCommandInput extends GetEvaluationInput {
-}
-export interface GetEvaluationCommandOutput extends GetEvaluationOutput, __MetadataBearer {
-}
-/**
- * <p>Returns an <code>Evaluation</code> that includes metadata as well as the current status of the <code>Evaluation</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, GetEvaluationCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, GetEvaluationCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new GetEvaluationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetEvaluationCommandInput} for command's `input` shape.
- * @see {@link GetEvaluationCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetEvaluationCommand extends $Command<GetEvaluationCommandInput, GetEvaluationCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: GetEvaluationCommandInput;
-    constructor(input: GetEvaluationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetEvaluationCommandInput, GetEvaluationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,37 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { GetMLModelInput, GetMLModelOutput } 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 GetMLModelCommandInput extends GetMLModelInput {
-}
-export interface GetMLModelCommandOutput extends GetMLModelOutput, __MetadataBearer {
-}
-/**
- * <p>Returns an <code>MLModel</code> that includes detailed metadata, data source information, and the current status of the <code>MLModel</code>.</p>
- *         <p>
- *             <code>GetMLModel</code> provides results in normal or verbose format. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, GetMLModelCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, GetMLModelCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new GetMLModelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetMLModelCommandInput} for command's `input` shape.
- * @see {@link GetMLModelCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetMLModelCommand extends $Command<GetMLModelCommandInput, GetMLModelCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: GetMLModelCommandInput;
-    constructor(input: GetMLModelCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetMLModelCommandInput, GetMLModelCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,38 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { PredictInput, PredictOutput } 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 PredictCommandInput extends PredictInput {
-}
-export interface PredictCommandOutput extends PredictOutput, __MetadataBearer {
-}
-/**
- * <p>Generates a prediction for the observation using the specified <code>ML Model</code>.</p>
- *         <p>
- *             <b>Note:</b> Not all response parameters will be populated. Whether a
- *           response parameter is populated depends on the type of model requested.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, PredictCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, PredictCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new PredictCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PredictCommandInput} for command's `input` shape.
- * @see {@link PredictCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PredictCommand extends $Command<PredictCommandInput, PredictCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: PredictCommandInput;
-    constructor(input: PredictCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PredictCommandInput, PredictCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,36 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { UpdateBatchPredictionInput, UpdateBatchPredictionOutput } 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 UpdateBatchPredictionCommandInput extends UpdateBatchPredictionInput {
-}
-export interface UpdateBatchPredictionCommandOutput extends UpdateBatchPredictionOutput, __MetadataBearer {
-}
-/**
- * <p>Updates the <code>BatchPredictionName</code> of a <code>BatchPrediction</code>.</p>
- *         <p>You can use the <code>GetBatchPrediction</code> operation to view the contents of the updated data element.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, UpdateBatchPredictionCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, UpdateBatchPredictionCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new UpdateBatchPredictionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateBatchPredictionCommandInput} for command's `input` shape.
- * @see {@link UpdateBatchPredictionCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateBatchPredictionCommand extends $Command<UpdateBatchPredictionCommandInput, UpdateBatchPredictionCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: UpdateBatchPredictionCommandInput;
-    constructor(input: UpdateBatchPredictionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateBatchPredictionCommandInput, UpdateBatchPredictionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,36 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { UpdateDataSourceInput, UpdateDataSourceOutput } 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 UpdateDataSourceCommandInput extends UpdateDataSourceInput {
-}
-export interface UpdateDataSourceCommandOutput extends UpdateDataSourceOutput, __MetadataBearer {
-}
-/**
- * <p>Updates the <code>DataSourceName</code> of a <code>DataSource</code>.</p>
- *         <p>You can use the <code>GetDataSource</code> operation to view the contents of the updated data element.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, UpdateDataSourceCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, UpdateDataSourceCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new UpdateDataSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateDataSourceCommandInput} for command's `input` shape.
- * @see {@link UpdateDataSourceCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateDataSourceCommand extends $Command<UpdateDataSourceCommandInput, UpdateDataSourceCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: UpdateDataSourceCommandInput;
-    constructor(input: UpdateDataSourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDataSourceCommandInput, UpdateDataSourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,36 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { UpdateEvaluationInput, UpdateEvaluationOutput } 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 UpdateEvaluationCommandInput extends UpdateEvaluationInput {
-}
-export interface UpdateEvaluationCommandOutput extends UpdateEvaluationOutput, __MetadataBearer {
-}
-/**
- * <p>Updates the <code>EvaluationName</code> of an <code>Evaluation</code>.</p>
- *         <p>You can use the <code>GetEvaluation</code> operation to view the contents of the updated data element.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, UpdateEvaluationCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, UpdateEvaluationCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new UpdateEvaluationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateEvaluationCommandInput} for command's `input` shape.
- * @see {@link UpdateEvaluationCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateEvaluationCommand extends $Command<UpdateEvaluationCommandInput, UpdateEvaluationCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: UpdateEvaluationCommandInput;
-    constructor(input: UpdateEvaluationCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateEvaluationCommandInput, UpdateEvaluationCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,36 +0,0 @@
-import { MachineLearningClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../MachineLearningClient";
-import { UpdateMLModelInput, UpdateMLModelOutput } 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 UpdateMLModelCommandInput extends UpdateMLModelInput {
-}
-export interface UpdateMLModelCommandOutput extends UpdateMLModelOutput, __MetadataBearer {
-}
-/**
- * <p>Updates the <code>MLModelName</code> and the <code>ScoreThreshold</code> of an <code>MLModel</code>.</p>
- *         <p>You can use the <code>GetMLModel</code> operation to view the contents of the updated data element.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { MachineLearningClient, UpdateMLModelCommand } from "@aws-sdk/client-machine-learning"; // ES Modules import
- * // const { MachineLearningClient, UpdateMLModelCommand } = require("@aws-sdk/client-machine-learning"); // CommonJS import
- * const client = new MachineLearningClient(config);
- * const command = new UpdateMLModelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateMLModelCommandInput} for command's `input` shape.
- * @see {@link UpdateMLModelCommandOutput} for command's `response` shape.
- * @see {@link MachineLearningClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class UpdateMLModelCommand extends $Command<UpdateMLModelCommandInput, UpdateMLModelCommandOutput, MachineLearningClientResolvedConfig> {
-    readonly input: UpdateMLModelCommandInput;
-    constructor(input: UpdateMLModelCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: MachineLearningClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateMLModelCommandInput, UpdateMLModelCommandOutput>;
-    private serialize;
-    private deserialize;
-}