@aws-sdk/client-lookoutequipment 3.35.0 → 3.38.0

package/dist-types/ts3.4/LookoutEquipment.d.ts

@@ -22,173 +22,93 @@ import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/Ta
 import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
 import { UpdateInferenceSchedulerCommandInput, UpdateInferenceSchedulerCommandOutput } from "./commands/UpdateInferenceSchedulerCommand";
 import { LookoutEquipmentClient } from "./LookoutEquipmentClient";
-/**
- * <p>Amazon Lookout for Equipment is a machine learning service that uses advanced analytics to identify
- *          anomalies in machines from sensor data for use in predictive maintenance. </p>
- */
+
 export declare class LookoutEquipment extends LookoutEquipmentClient {
-    /**
-     * <p>Creates a container for a collection of data being ingested for analysis. The dataset
-     *          contains the metadata describing where the data is and what the data actually looks like.
-     *          In other words, it contains the location of the data source, the data schema, and other
-     *          information. A dataset also contains any tags associated with the ingested data. </p>
-     */
+    
     createDataset(args: CreateDatasetCommandInput, options?: __HttpHandlerOptions): Promise<CreateDatasetCommandOutput>;
     createDataset(args: CreateDatasetCommandInput, cb: (err: any, data?: CreateDatasetCommandOutput) => void): void;
     createDataset(args: CreateDatasetCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateDatasetCommandOutput) => void): void;
-    /**
-     * <p> Creates a scheduled inference. Scheduling an inference is setting up a continuous
-     *          real-time inference plan to analyze new measurement data. When setting up the schedule, you
-     *          provide an S3 bucket location for the input data, assign it a delimiter between separate
-     *          entries in the data, set an offset delay if desired, and set the frequency of inferencing.
-     *          You must also provide an S3 bucket location for the output data. </p>
-     */
+    
     createInferenceScheduler(args: CreateInferenceSchedulerCommandInput, options?: __HttpHandlerOptions): Promise<CreateInferenceSchedulerCommandOutput>;
     createInferenceScheduler(args: CreateInferenceSchedulerCommandInput, cb: (err: any, data?: CreateInferenceSchedulerCommandOutput) => void): void;
     createInferenceScheduler(args: CreateInferenceSchedulerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateInferenceSchedulerCommandOutput) => void): void;
-    /**
-     * <p>Creates an ML model for data inference. </p>
-     *          <p>A machine-learning (ML) model is a mathematical model that finds patterns in your data.
-     *          In Amazon Lookout for Equipment, the model learns the patterns of normal behavior and detects abnormal
-     *          behavior that could be potential equipment failure (or maintenance events). The models are
-     *          made by analyzing normal data and abnormalities in machine behavior that have already
-     *          occurred.</p>
-     *          <p>Your model is trained using a portion of the data from your dataset and uses that data
-     *          to learn patterns of normal behavior and abnormal patterns that lead to equipment failure.
-     *          Another portion of the data is used to evaluate the model's accuracy. </p>
-     */
+    
     createModel(args: CreateModelCommandInput, options?: __HttpHandlerOptions): Promise<CreateModelCommandOutput>;
     createModel(args: CreateModelCommandInput, cb: (err: any, data?: CreateModelCommandOutput) => void): void;
     createModel(args: CreateModelCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: CreateModelCommandOutput) => void): void;
-    /**
-     * <p> Deletes a dataset and associated artifacts. The operation will check to see if any
-     *          inference scheduler or data ingestion job is currently using the dataset, and if there
-     *          isn't, the dataset, its metadata, and any associated data stored in S3 will be deleted.
-     *          This does not affect any models that used this dataset for training and evaluation, but
-     *          does prevent it from being used in the future. </p>
-     */
+    
     deleteDataset(args: DeleteDatasetCommandInput, options?: __HttpHandlerOptions): Promise<DeleteDatasetCommandOutput>;
     deleteDataset(args: DeleteDatasetCommandInput, cb: (err: any, data?: DeleteDatasetCommandOutput) => void): void;
     deleteDataset(args: DeleteDatasetCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteDatasetCommandOutput) => void): void;
-    /**
-     * <p>Deletes an inference scheduler that has been set up. Already processed output results
-     *          are not affected. </p>
-     */
+    
     deleteInferenceScheduler(args: DeleteInferenceSchedulerCommandInput, options?: __HttpHandlerOptions): Promise<DeleteInferenceSchedulerCommandOutput>;
     deleteInferenceScheduler(args: DeleteInferenceSchedulerCommandInput, cb: (err: any, data?: DeleteInferenceSchedulerCommandOutput) => void): void;
     deleteInferenceScheduler(args: DeleteInferenceSchedulerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteInferenceSchedulerCommandOutput) => void): void;
-    /**
-     * <p>Deletes an ML model currently available for Amazon Lookout for Equipment. This will prevent it from
-     *          being used with an inference scheduler, even one that is already set up. </p>
-     */
+    
     deleteModel(args: DeleteModelCommandInput, options?: __HttpHandlerOptions): Promise<DeleteModelCommandOutput>;
     deleteModel(args: DeleteModelCommandInput, cb: (err: any, data?: DeleteModelCommandOutput) => void): void;
     deleteModel(args: DeleteModelCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteModelCommandOutput) => void): void;
-    /**
-     * <p>Provides information on a specific data ingestion job such as creation time, dataset
-     *          ARN, status, and so on. </p>
-     */
+    
     describeDataIngestionJob(args: DescribeDataIngestionJobCommandInput, options?: __HttpHandlerOptions): Promise<DescribeDataIngestionJobCommandOutput>;
     describeDataIngestionJob(args: DescribeDataIngestionJobCommandInput, cb: (err: any, data?: DescribeDataIngestionJobCommandOutput) => void): void;
     describeDataIngestionJob(args: DescribeDataIngestionJobCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeDataIngestionJobCommandOutput) => void): void;
-    /**
-     * <p>Provides a JSON description of the data that is in each time series dataset, including names, column names, and data types.</p>
-     */
+    
     describeDataset(args: DescribeDatasetCommandInput, options?: __HttpHandlerOptions): Promise<DescribeDatasetCommandOutput>;
     describeDataset(args: DescribeDatasetCommandInput, cb: (err: any, data?: DescribeDatasetCommandOutput) => void): void;
     describeDataset(args: DescribeDatasetCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeDatasetCommandOutput) => void): void;
-    /**
-     * <p> Specifies information about the inference scheduler being used, including name, model,
-     *          status, and associated metadata </p>
-     */
+    
     describeInferenceScheduler(args: DescribeInferenceSchedulerCommandInput, options?: __HttpHandlerOptions): Promise<DescribeInferenceSchedulerCommandOutput>;
     describeInferenceScheduler(args: DescribeInferenceSchedulerCommandInput, cb: (err: any, data?: DescribeInferenceSchedulerCommandOutput) => void): void;
     describeInferenceScheduler(args: DescribeInferenceSchedulerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeInferenceSchedulerCommandOutput) => void): void;
-    /**
-     * <p>Provides a JSON containing the overall information about a specific ML model, including model name and ARN,
-     *          dataset, training and evaluation information, status, and so on. </p>
-     */
+    
     describeModel(args: DescribeModelCommandInput, options?: __HttpHandlerOptions): Promise<DescribeModelCommandOutput>;
     describeModel(args: DescribeModelCommandInput, cb: (err: any, data?: DescribeModelCommandOutput) => void): void;
     describeModel(args: DescribeModelCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DescribeModelCommandOutput) => void): void;
-    /**
-     * <p>Provides a list of all data ingestion jobs, including dataset name and ARN, S3 location
-     *          of the input data, status, and so on. </p>
-     */
+    
     listDataIngestionJobs(args: ListDataIngestionJobsCommandInput, options?: __HttpHandlerOptions): Promise<ListDataIngestionJobsCommandOutput>;
     listDataIngestionJobs(args: ListDataIngestionJobsCommandInput, cb: (err: any, data?: ListDataIngestionJobsCommandOutput) => void): void;
     listDataIngestionJobs(args: ListDataIngestionJobsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListDataIngestionJobsCommandOutput) => void): void;
-    /**
-     * <p>Lists all datasets currently available in your account, filtering on the dataset name.
-     *       </p>
-     */
+    
     listDatasets(args: ListDatasetsCommandInput, options?: __HttpHandlerOptions): Promise<ListDatasetsCommandOutput>;
     listDatasets(args: ListDatasetsCommandInput, cb: (err: any, data?: ListDatasetsCommandOutput) => void): void;
     listDatasets(args: ListDatasetsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListDatasetsCommandOutput) => void): void;
-    /**
-     * <p> Lists all inference executions that have been performed by the specified inference
-     *          scheduler. </p>
-     */
+    
     listInferenceExecutions(args: ListInferenceExecutionsCommandInput, options?: __HttpHandlerOptions): Promise<ListInferenceExecutionsCommandOutput>;
     listInferenceExecutions(args: ListInferenceExecutionsCommandInput, cb: (err: any, data?: ListInferenceExecutionsCommandOutput) => void): void;
     listInferenceExecutions(args: ListInferenceExecutionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListInferenceExecutionsCommandOutput) => void): void;
-    /**
-     * <p>Retrieves a list of all inference schedulers currently available for your account.
-     *       </p>
-     */
+    
     listInferenceSchedulers(args: ListInferenceSchedulersCommandInput, options?: __HttpHandlerOptions): Promise<ListInferenceSchedulersCommandOutput>;
     listInferenceSchedulers(args: ListInferenceSchedulersCommandInput, cb: (err: any, data?: ListInferenceSchedulersCommandOutput) => void): void;
     listInferenceSchedulers(args: ListInferenceSchedulersCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListInferenceSchedulersCommandOutput) => void): void;
-    /**
-     * <p>Generates a list of all models in the account, including model name and ARN, dataset,
-     *          and status. </p>
-     */
+    
     listModels(args: ListModelsCommandInput, options?: __HttpHandlerOptions): Promise<ListModelsCommandOutput>;
     listModels(args: ListModelsCommandInput, cb: (err: any, data?: ListModelsCommandOutput) => void): void;
     listModels(args: ListModelsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListModelsCommandOutput) => void): void;
-    /**
-     * <p>Lists all the tags for a specified resource, including key and value. </p>
-     */
+    
     listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
     listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
-    /**
-     * <p>Starts a data ingestion job. Amazon Lookout for Equipment returns the job status. </p>
-     */
+    
     startDataIngestionJob(args: StartDataIngestionJobCommandInput, options?: __HttpHandlerOptions): Promise<StartDataIngestionJobCommandOutput>;
     startDataIngestionJob(args: StartDataIngestionJobCommandInput, cb: (err: any, data?: StartDataIngestionJobCommandOutput) => void): void;
     startDataIngestionJob(args: StartDataIngestionJobCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartDataIngestionJobCommandOutput) => void): void;
-    /**
-     * <p>Starts an inference scheduler. </p>
-     */
+    
     startInferenceScheduler(args: StartInferenceSchedulerCommandInput, options?: __HttpHandlerOptions): Promise<StartInferenceSchedulerCommandOutput>;
     startInferenceScheduler(args: StartInferenceSchedulerCommandInput, cb: (err: any, data?: StartInferenceSchedulerCommandOutput) => void): void;
     startInferenceScheduler(args: StartInferenceSchedulerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StartInferenceSchedulerCommandOutput) => void): void;
-    /**
-     * <p>Stops an inference scheduler. </p>
-     */
+    
     stopInferenceScheduler(args: StopInferenceSchedulerCommandInput, options?: __HttpHandlerOptions): Promise<StopInferenceSchedulerCommandOutput>;
     stopInferenceScheduler(args: StopInferenceSchedulerCommandInput, cb: (err: any, data?: StopInferenceSchedulerCommandOutput) => void): void;
     stopInferenceScheduler(args: StopInferenceSchedulerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: StopInferenceSchedulerCommandOutput) => void): void;
-    /**
-     * <p>Associates a given tag to a resource in your account. A tag is a key-value pair which
-     *          can be added to an Amazon Lookout for Equipment resource as metadata. Tags can be used for organizing your
-     *          resources as well as helping you to search and filter by tag. Multiple tags can be added to
-     *          a resource, either when you create it, or later. Up to 50 tags can be associated with each
-     *          resource. </p>
-     */
+    
     tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
     tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
-    /**
-     * <p>Removes a specific tag from a given resource. The tag is specified by its key. </p>
-     */
+    
     untagResource(args: UntagResourceCommandInput, options?: __HttpHandlerOptions): Promise<UntagResourceCommandOutput>;
     untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
-    /**
-     * <p>Updates an inference scheduler. </p>
-     */
+    
     updateInferenceScheduler(args: UpdateInferenceSchedulerCommandInput, options?: __HttpHandlerOptions): Promise<UpdateInferenceSchedulerCommandOutput>;
     updateInferenceScheduler(args: UpdateInferenceSchedulerCommandInput, cb: (err: any, data?: UpdateInferenceSchedulerCommandOutput) => void): void;
     updateInferenceScheduler(args: UpdateInferenceSchedulerCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateInferenceSchedulerCommandOutput) => void): void;

package/dist-types/ts3.4/LookoutEquipmentClient.d.ts

@@ -31,125 +31,59 @@ import { UpdateInferenceSchedulerCommandInput, UpdateInferenceSchedulerCommandOu
 export declare type ServiceInputTypes = CreateDatasetCommandInput | CreateInferenceSchedulerCommandInput | CreateModelCommandInput | DeleteDatasetCommandInput | DeleteInferenceSchedulerCommandInput | DeleteModelCommandInput | DescribeDataIngestionJobCommandInput | DescribeDatasetCommandInput | DescribeInferenceSchedulerCommandInput | DescribeModelCommandInput | ListDataIngestionJobsCommandInput | ListDatasetsCommandInput | ListInferenceExecutionsCommandInput | ListInferenceSchedulersCommandInput | ListModelsCommandInput | ListTagsForResourceCommandInput | StartDataIngestionJobCommandInput | StartInferenceSchedulerCommandInput | StopInferenceSchedulerCommandInput | TagResourceCommandInput | UntagResourceCommandInput | UpdateInferenceSchedulerCommandInput;
 export declare type ServiceOutputTypes = CreateDatasetCommandOutput | CreateInferenceSchedulerCommandOutput | CreateModelCommandOutput | DeleteDatasetCommandOutput | DeleteInferenceSchedulerCommandOutput | DeleteModelCommandOutput | DescribeDataIngestionJobCommandOutput | DescribeDatasetCommandOutput | DescribeInferenceSchedulerCommandOutput | DescribeModelCommandOutput | ListDataIngestionJobsCommandOutput | ListDatasetsCommandOutput | ListInferenceExecutionsCommandOutput | ListInferenceSchedulersCommandOutput | ListModelsCommandOutput | ListTagsForResourceCommandOutput | StartDataIngestionJobCommandOutput | StartInferenceSchedulerCommandOutput | StopInferenceSchedulerCommandOutput | TagResourceCommandOutput | UntagResourceCommandOutput | UpdateInferenceSchedulerCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type LookoutEquipmentClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of LookoutEquipmentClient class constructor that set the region, credentials and other options.
- */
+
 export interface LookoutEquipmentClientConfig extends LookoutEquipmentClientConfigType {
 }
 declare type LookoutEquipmentClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of LookoutEquipmentClient class. This is resolved and normalized from the {@link LookoutEquipmentClientConfig | constructor configuration interface}.
- */
+
 export interface LookoutEquipmentClientResolvedConfig extends LookoutEquipmentClientResolvedConfigType {
 }
-/**
- * <p>Amazon Lookout for Equipment is a machine learning service that uses advanced analytics to identify
- *          anomalies in machines from sensor data for use in predictive maintenance. </p>
- */
+
 export declare class LookoutEquipmentClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, LookoutEquipmentClientResolvedConfig> {
-    /**
-     * The resolved configuration of LookoutEquipmentClient class. This is resolved and normalized from the {@link LookoutEquipmentClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: LookoutEquipmentClientResolvedConfig;
     constructor(configuration: LookoutEquipmentClientConfig);
-    /**
-     * 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(): void;
 }
 export {};

package/dist-types/ts3.4/commands/CreateDatasetCommand.d.ts

@@ -6,32 +6,11 @@ export interface CreateDatasetCommandInput extends CreateDatasetRequest {
 }
 export interface CreateDatasetCommandOutput extends CreateDatasetResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a container for a collection of data being ingested for analysis. The dataset
- *          contains the metadata describing where the data is and what the data actually looks like.
- *          In other words, it contains the location of the data source, the data schema, and other
- *          information. A dataset also contains any tags associated with the ingested data. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LookoutEquipmentClient, CreateDatasetCommand } from "@aws-sdk/client-lookoutequipment"; // ES Modules import
- * // const { LookoutEquipmentClient, CreateDatasetCommand } = require("@aws-sdk/client-lookoutequipment"); // CommonJS import
- * const client = new LookoutEquipmentClient(config);
- * const command = new CreateDatasetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDatasetCommandInput} for command's `input` shape.
- * @see {@link CreateDatasetCommandOutput} for command's `response` shape.
- * @see {@link LookoutEquipmentClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDatasetCommand extends $Command<CreateDatasetCommandInput, CreateDatasetCommandOutput, LookoutEquipmentClientResolvedConfig> {
     readonly input: CreateDatasetCommandInput;
     constructor(input: CreateDatasetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LookoutEquipmentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDatasetCommandInput, CreateDatasetCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateInferenceSchedulerCommand.d.ts

@@ -6,33 +6,11 @@ export interface CreateInferenceSchedulerCommandInput extends CreateInferenceSch
 }
 export interface CreateInferenceSchedulerCommandOutput extends CreateInferenceSchedulerResponse, __MetadataBearer {
 }
-/**
- * <p> Creates a scheduled inference. Scheduling an inference is setting up a continuous
- *          real-time inference plan to analyze new measurement data. When setting up the schedule, you
- *          provide an S3 bucket location for the input data, assign it a delimiter between separate
- *          entries in the data, set an offset delay if desired, and set the frequency of inferencing.
- *          You must also provide an S3 bucket location for the output data. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LookoutEquipmentClient, CreateInferenceSchedulerCommand } from "@aws-sdk/client-lookoutequipment"; // ES Modules import
- * // const { LookoutEquipmentClient, CreateInferenceSchedulerCommand } = require("@aws-sdk/client-lookoutequipment"); // CommonJS import
- * const client = new LookoutEquipmentClient(config);
- * const command = new CreateInferenceSchedulerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateInferenceSchedulerCommandInput} for command's `input` shape.
- * @see {@link CreateInferenceSchedulerCommandOutput} for command's `response` shape.
- * @see {@link LookoutEquipmentClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateInferenceSchedulerCommand extends $Command<CreateInferenceSchedulerCommandInput, CreateInferenceSchedulerCommandOutput, LookoutEquipmentClientResolvedConfig> {
     readonly input: CreateInferenceSchedulerCommandInput;
     constructor(input: CreateInferenceSchedulerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LookoutEquipmentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateInferenceSchedulerCommandInput, CreateInferenceSchedulerCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/CreateModelCommand.d.ts

@@ -6,37 +6,11 @@ export interface CreateModelCommandInput extends CreateModelRequest {
 }
 export interface CreateModelCommandOutput extends CreateModelResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an ML model for data inference. </p>
- *          <p>A machine-learning (ML) model is a mathematical model that finds patterns in your data.
- *          In Amazon Lookout for Equipment, the model learns the patterns of normal behavior and detects abnormal
- *          behavior that could be potential equipment failure (or maintenance events). The models are
- *          made by analyzing normal data and abnormalities in machine behavior that have already
- *          occurred.</p>
- *          <p>Your model is trained using a portion of the data from your dataset and uses that data
- *          to learn patterns of normal behavior and abnormal patterns that lead to equipment failure.
- *          Another portion of the data is used to evaluate the model's accuracy. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LookoutEquipmentClient, CreateModelCommand } from "@aws-sdk/client-lookoutequipment"; // ES Modules import
- * // const { LookoutEquipmentClient, CreateModelCommand } = require("@aws-sdk/client-lookoutequipment"); // CommonJS import
- * const client = new LookoutEquipmentClient(config);
- * const command = new CreateModelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateModelCommandInput} for command's `input` shape.
- * @see {@link CreateModelCommandOutput} for command's `response` shape.
- * @see {@link LookoutEquipmentClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateModelCommand extends $Command<CreateModelCommandInput, CreateModelCommandOutput, LookoutEquipmentClientResolvedConfig> {
     readonly input: CreateModelCommandInput;
     constructor(input: CreateModelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LookoutEquipmentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateModelCommandInput, CreateModelCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteDatasetCommand.d.ts

@@ -6,33 +6,11 @@ export interface DeleteDatasetCommandInput extends DeleteDatasetRequest {
 }
 export interface DeleteDatasetCommandOutput extends __MetadataBearer {
 }
-/**
- * <p> Deletes a dataset and associated artifacts. The operation will check to see if any
- *          inference scheduler or data ingestion job is currently using the dataset, and if there
- *          isn't, the dataset, its metadata, and any associated data stored in S3 will be deleted.
- *          This does not affect any models that used this dataset for training and evaluation, but
- *          does prevent it from being used in the future. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LookoutEquipmentClient, DeleteDatasetCommand } from "@aws-sdk/client-lookoutequipment"; // ES Modules import
- * // const { LookoutEquipmentClient, DeleteDatasetCommand } = require("@aws-sdk/client-lookoutequipment"); // CommonJS import
- * const client = new LookoutEquipmentClient(config);
- * const command = new DeleteDatasetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDatasetCommandInput} for command's `input` shape.
- * @see {@link DeleteDatasetCommandOutput} for command's `response` shape.
- * @see {@link LookoutEquipmentClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDatasetCommand extends $Command<DeleteDatasetCommandInput, DeleteDatasetCommandOutput, LookoutEquipmentClientResolvedConfig> {
     readonly input: DeleteDatasetCommandInput;
     constructor(input: DeleteDatasetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LookoutEquipmentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDatasetCommandInput, DeleteDatasetCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteInferenceSchedulerCommand.d.ts

@@ -6,30 +6,11 @@ export interface DeleteInferenceSchedulerCommandInput extends DeleteInferenceSch
 }
 export interface DeleteInferenceSchedulerCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes an inference scheduler that has been set up. Already processed output results
- *          are not affected. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LookoutEquipmentClient, DeleteInferenceSchedulerCommand } from "@aws-sdk/client-lookoutequipment"; // ES Modules import
- * // const { LookoutEquipmentClient, DeleteInferenceSchedulerCommand } = require("@aws-sdk/client-lookoutequipment"); // CommonJS import
- * const client = new LookoutEquipmentClient(config);
- * const command = new DeleteInferenceSchedulerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteInferenceSchedulerCommandInput} for command's `input` shape.
- * @see {@link DeleteInferenceSchedulerCommandOutput} for command's `response` shape.
- * @see {@link LookoutEquipmentClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteInferenceSchedulerCommand extends $Command<DeleteInferenceSchedulerCommandInput, DeleteInferenceSchedulerCommandOutput, LookoutEquipmentClientResolvedConfig> {
     readonly input: DeleteInferenceSchedulerCommandInput;
     constructor(input: DeleteInferenceSchedulerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LookoutEquipmentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInferenceSchedulerCommandInput, DeleteInferenceSchedulerCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DeleteModelCommand.d.ts

@@ -6,30 +6,11 @@ export interface DeleteModelCommandInput extends DeleteModelRequest {
 }
 export interface DeleteModelCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes an ML model currently available for Amazon Lookout for Equipment. This will prevent it from
- *          being used with an inference scheduler, even one that is already set up. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LookoutEquipmentClient, DeleteModelCommand } from "@aws-sdk/client-lookoutequipment"; // ES Modules import
- * // const { LookoutEquipmentClient, DeleteModelCommand } = require("@aws-sdk/client-lookoutequipment"); // CommonJS import
- * const client = new LookoutEquipmentClient(config);
- * const command = new DeleteModelCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteModelCommandInput} for command's `input` shape.
- * @see {@link DeleteModelCommandOutput} for command's `response` shape.
- * @see {@link LookoutEquipmentClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteModelCommand extends $Command<DeleteModelCommandInput, DeleteModelCommandOutput, LookoutEquipmentClientResolvedConfig> {
     readonly input: DeleteModelCommandInput;
     constructor(input: DeleteModelCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LookoutEquipmentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteModelCommandInput, DeleteModelCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeDataIngestionJobCommand.d.ts

@@ -6,30 +6,11 @@ export interface DescribeDataIngestionJobCommandInput extends DescribeDataIngest
 }
 export interface DescribeDataIngestionJobCommandOutput extends DescribeDataIngestionJobResponse, __MetadataBearer {
 }
-/**
- * <p>Provides information on a specific data ingestion job such as creation time, dataset
- *          ARN, status, and so on. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LookoutEquipmentClient, DescribeDataIngestionJobCommand } from "@aws-sdk/client-lookoutequipment"; // ES Modules import
- * // const { LookoutEquipmentClient, DescribeDataIngestionJobCommand } = require("@aws-sdk/client-lookoutequipment"); // CommonJS import
- * const client = new LookoutEquipmentClient(config);
- * const command = new DescribeDataIngestionJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDataIngestionJobCommandInput} for command's `input` shape.
- * @see {@link DescribeDataIngestionJobCommandOutput} for command's `response` shape.
- * @see {@link LookoutEquipmentClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDataIngestionJobCommand extends $Command<DescribeDataIngestionJobCommandInput, DescribeDataIngestionJobCommandOutput, LookoutEquipmentClientResolvedConfig> {
     readonly input: DescribeDataIngestionJobCommandInput;
     constructor(input: DescribeDataIngestionJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LookoutEquipmentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDataIngestionJobCommandInput, DescribeDataIngestionJobCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/DescribeDatasetCommand.d.ts

@@ -6,29 +6,11 @@ export interface DescribeDatasetCommandInput extends DescribeDatasetRequest {
 }
 export interface DescribeDatasetCommandOutput extends DescribeDatasetResponse, __MetadataBearer {
 }
-/**
- * <p>Provides a JSON description of the data that is in each time series dataset, including names, column names, and data types.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { LookoutEquipmentClient, DescribeDatasetCommand } from "@aws-sdk/client-lookoutequipment"; // ES Modules import
- * // const { LookoutEquipmentClient, DescribeDatasetCommand } = require("@aws-sdk/client-lookoutequipment"); // CommonJS import
- * const client = new LookoutEquipmentClient(config);
- * const command = new DescribeDatasetCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDatasetCommandInput} for command's `input` shape.
- * @see {@link DescribeDatasetCommandOutput} for command's `response` shape.
- * @see {@link LookoutEquipmentClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDatasetCommand extends $Command<DescribeDatasetCommandInput, DescribeDatasetCommandOutput, LookoutEquipmentClientResolvedConfig> {
     readonly input: DescribeDatasetCommandInput;
     constructor(input: DescribeDatasetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: LookoutEquipmentClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDatasetCommandInput, DescribeDatasetCommandOutput>;
     private serialize;
     private deserialize;