@aws-sdk/client-personalize 3.35.0 → 3.38.0

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

@@ -6,31 +6,11 @@ export interface DescribeBatchInferenceJobCommandInput extends DescribeBatchInfe
 }
 export interface DescribeBatchInferenceJobCommandOutput extends DescribeBatchInferenceJobResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the properties of a batch inference job including name, Amazon Resource Name (ARN),
- *       status, input and output configurations, and the ARN of the solution version used to generate
- *       the recommendations.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeBatchInferenceJobCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeBatchInferenceJobCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeBatchInferenceJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeBatchInferenceJobCommandInput} for command's `input` shape.
- * @see {@link DescribeBatchInferenceJobCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeBatchInferenceJobCommand extends $Command<DescribeBatchInferenceJobCommandInput, DescribeBatchInferenceJobCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeBatchInferenceJobCommandInput;
     constructor(input: DescribeBatchInferenceJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeBatchInferenceJobCommandInput, DescribeBatchInferenceJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface DescribeCampaignCommandInput extends DescribeCampaignRequest {
 }
 export interface DescribeCampaignCommandOutput extends DescribeCampaignResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the given campaign, including its status.</p>
- *          <p>A campaign can be in one of the following states:</p>
- *          <ul>
- *             <li>
- *                <p>CREATE PENDING > CREATE IN_PROGRESS > ACTIVE -or- CREATE FAILED</p>
- *             </li>
- *             <li>
- *                <p>DELETE PENDING > DELETE IN_PROGRESS</p>
- *             </li>
- *          </ul>
- *          <p>When the <code>status</code> is <code>CREATE FAILED</code>, the response includes the
- *       <code>failureReason</code> key, which describes why.</p>
- *          <p>For more information on campaigns, see <a>CreateCampaign</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeCampaignCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeCampaignCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeCampaignCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeCampaignCommandInput} for command's `input` shape.
- * @see {@link DescribeCampaignCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeCampaignCommand extends $Command<DescribeCampaignCommandInput, DescribeCampaignCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeCampaignCommandInput;
     constructor(input: DescribeCampaignCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeCampaignCommandInput, DescribeCampaignCommandOutput>;
     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>Describes the given dataset. For more information on datasets, see <a>CreateDataset</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeDatasetCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeDatasetCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(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 PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDatasetCommand extends $Command<DescribeDatasetCommandInput, DescribeDatasetCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeDatasetCommandInput;
     constructor(input: DescribeDatasetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDatasetCommandInput, DescribeDatasetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeDatasetExportJobCommandInput extends DescribeDatasetExp
 }
 export interface DescribeDatasetExportJobCommandOutput extends DescribeDatasetExportJobResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the dataset export job created by <a>CreateDatasetExportJob</a>,
- *       including the export job status.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeDatasetExportJobCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeDatasetExportJobCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeDatasetExportJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDatasetExportJobCommandInput} for command's `input` shape.
- * @see {@link DescribeDatasetExportJobCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDatasetExportJobCommand extends $Command<DescribeDatasetExportJobCommandInput, DescribeDatasetExportJobCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeDatasetExportJobCommandInput;
     constructor(input: DescribeDatasetExportJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDatasetExportJobCommandInput, DescribeDatasetExportJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeDatasetGroupCommandInput extends DescribeDatasetGroupRe
 }
 export interface DescribeDatasetGroupCommandOutput extends DescribeDatasetGroupResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the given dataset group. For more information on dataset groups, see <a>CreateDatasetGroup</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeDatasetGroupCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeDatasetGroupCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeDatasetGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDatasetGroupCommandInput} for command's `input` shape.
- * @see {@link DescribeDatasetGroupCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDatasetGroupCommand extends $Command<DescribeDatasetGroupCommandInput, DescribeDatasetGroupCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeDatasetGroupCommandInput;
     constructor(input: DescribeDatasetGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDatasetGroupCommandInput, DescribeDatasetGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeDatasetImportJobCommandInput extends DescribeDatasetImp
 }
 export interface DescribeDatasetImportJobCommandOutput extends DescribeDatasetImportJobResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the dataset import job created by <a>CreateDatasetImportJob</a>,
- *       including the import job status.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeDatasetImportJobCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeDatasetImportJobCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeDatasetImportJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDatasetImportJobCommandInput} for command's `input` shape.
- * @see {@link DescribeDatasetImportJobCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDatasetImportJobCommand extends $Command<DescribeDatasetImportJobCommandInput, DescribeDatasetImportJobCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeDatasetImportJobCommandInput;
     constructor(input: DescribeDatasetImportJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDatasetImportJobCommandInput, DescribeDatasetImportJobCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeEventTrackerCommandInput extends DescribeEventTrackerRe
 }
 export interface DescribeEventTrackerCommandOutput extends DescribeEventTrackerResponse, __MetadataBearer {
 }
-/**
- * <p>Describes an event tracker. The response includes the <code>trackingId</code> and
- *       <code>status</code> of the event tracker.
- *       For more information on event trackers, see <a>CreateEventTracker</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeEventTrackerCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeEventTrackerCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeEventTrackerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeEventTrackerCommandInput} for command's `input` shape.
- * @see {@link DescribeEventTrackerCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeEventTrackerCommand extends $Command<DescribeEventTrackerCommandInput, DescribeEventTrackerCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeEventTrackerCommandInput;
     constructor(input: DescribeEventTrackerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeEventTrackerCommandInput, DescribeEventTrackerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeFeatureTransformationCommandInput extends DescribeFeatu
 }
 export interface DescribeFeatureTransformationCommandOutput extends DescribeFeatureTransformationResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the given feature transformation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeFeatureTransformationCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeFeatureTransformationCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeFeatureTransformationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFeatureTransformationCommandInput} for command's `input` shape.
- * @see {@link DescribeFeatureTransformationCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFeatureTransformationCommand extends $Command<DescribeFeatureTransformationCommandInput, DescribeFeatureTransformationCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeFeatureTransformationCommandInput;
     constructor(input: DescribeFeatureTransformationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFeatureTransformationCommandInput, DescribeFeatureTransformationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeFilterCommandInput extends DescribeFilterRequest {
 }
 export interface DescribeFilterCommandOutput extends DescribeFilterResponse, __MetadataBearer {
 }
-/**
- * <p>Describes a filter's properties.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeFilterCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeFilterCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeFilterCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFilterCommandInput} for command's `input` shape.
- * @see {@link DescribeFilterCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFilterCommand extends $Command<DescribeFilterCommandInput, DescribeFilterCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeFilterCommandInput;
     constructor(input: DescribeFilterCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFilterCommandInput, DescribeFilterCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,47 +6,11 @@ export interface DescribeRecipeCommandInput extends DescribeRecipeRequest {
 }
 export interface DescribeRecipeCommandOutput extends DescribeRecipeResponse, __MetadataBearer {
 }
-/**
- * <p>Describes a recipe.</p>
- *          <p>A recipe contains three items:</p>
- *          <ul>
- *             <li>
- *                <p>An algorithm that trains a model.</p>
- *             </li>
- *             <li>
- *                <p>Hyperparameters that govern the training.</p>
- *             </li>
- *             <li>
- *                <p>Feature transformation information for modifying the input data before training.</p>
- *             </li>
- *          </ul>
- *          <p>Amazon Personalize provides a set of predefined recipes. You specify a recipe when you create a
- *       solution with the <a>CreateSolution</a> API.
- *       <code>CreateSolution</code> trains a model by using the algorithm
- *       in the specified recipe and a training dataset. The solution, when deployed as a campaign,
- *       can provide recommendations using the
- *       <a href="https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html">GetRecommendations</a> API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeRecipeCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeRecipeCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeRecipeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeRecipeCommandInput} for command's `input` shape.
- * @see {@link DescribeRecipeCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeRecipeCommand extends $Command<DescribeRecipeCommandInput, DescribeRecipeCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeRecipeCommandInput;
     constructor(input: DescribeRecipeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeRecipeCommandInput, DescribeRecipeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeSchemaCommandInput extends DescribeSchemaRequest {
 }
 export interface DescribeSchemaCommandOutput extends DescribeSchemaResponse, __MetadataBearer {
 }
-/**
- * <p>Describes a schema. For more information on schemas, see
- *       <a>CreateSchema</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeSchemaCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeSchemaCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeSchemaCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSchemaCommandInput} for command's `input` shape.
- * @see {@link DescribeSchemaCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSchemaCommand extends $Command<DescribeSchemaCommandInput, DescribeSchemaCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeSchemaCommandInput;
     constructor(input: DescribeSchemaCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSchemaCommandInput, DescribeSchemaCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DescribeSolutionCommandInput extends DescribeSolutionRequest {
 }
 export interface DescribeSolutionCommandOutput extends DescribeSolutionResponse, __MetadataBearer {
 }
-/**
- * <p>Describes a solution.
- *       For more information on solutions, see <a>CreateSolution</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeSolutionCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeSolutionCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeSolutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSolutionCommandInput} for command's `input` shape.
- * @see {@link DescribeSolutionCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSolutionCommand extends $Command<DescribeSolutionCommandInput, DescribeSolutionCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeSolutionCommandInput;
     constructor(input: DescribeSolutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSolutionCommandInput, DescribeSolutionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeSolutionVersionCommandInput extends DescribeSolutionVer
 }
 export interface DescribeSolutionVersionCommandOutput extends DescribeSolutionVersionResponse, __MetadataBearer {
 }
-/**
- * <p>Describes a specific version of a solution. For more information on solutions, see <a>CreateSolution</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DescribeSolutionVersionCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DescribeSolutionVersionCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DescribeSolutionVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeSolutionVersionCommandInput} for command's `input` shape.
- * @see {@link DescribeSolutionVersionCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeSolutionVersionCommand extends $Command<DescribeSolutionVersionCommandInput, DescribeSolutionVersionCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DescribeSolutionVersionCommandInput;
     constructor(input: DescribeSolutionVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeSolutionVersionCommandInput, DescribeSolutionVersionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetSolutionMetricsCommandInput extends GetSolutionMetricsReques
 }
 export interface GetSolutionMetricsCommandOutput extends GetSolutionMetricsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets the metrics for the specified solution version.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, GetSolutionMetricsCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, GetSolutionMetricsCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new GetSolutionMetricsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSolutionMetricsCommandInput} for command's `input` shape.
- * @see {@link GetSolutionMetricsCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSolutionMetricsCommand extends $Command<GetSolutionMetricsCommandInput, GetSolutionMetricsCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: GetSolutionMetricsCommandInput;
     constructor(input: GetSolutionMetricsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSolutionMetricsCommandInput, GetSolutionMetricsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListBatchInferenceJobsCommandInput extends ListBatchInferenceJo
 }
 export interface ListBatchInferenceJobsCommandOutput extends ListBatchInferenceJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of the batch inference jobs that have been performed off of a solution
- *       version.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, ListBatchInferenceJobsCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, ListBatchInferenceJobsCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new ListBatchInferenceJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListBatchInferenceJobsCommandInput} for command's `input` shape.
- * @see {@link ListBatchInferenceJobsCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListBatchInferenceJobsCommand extends $Command<ListBatchInferenceJobsCommandInput, ListBatchInferenceJobsCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: ListBatchInferenceJobsCommandInput;
     constructor(input: ListBatchInferenceJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBatchInferenceJobsCommandInput, ListBatchInferenceJobsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface ListCampaignsCommandInput extends ListCampaignsRequest {
 }
 export interface ListCampaignsCommandOutput extends ListCampaignsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of campaigns that use the given solution.
- *       When a solution is not specified, all the campaigns associated with the account are listed.
- *       The response provides the properties for each campaign, including the Amazon Resource Name (ARN).
- *       For more information on campaigns, see <a>CreateCampaign</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, ListCampaignsCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, ListCampaignsCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new ListCampaignsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListCampaignsCommandInput} for command's `input` shape.
- * @see {@link ListCampaignsCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListCampaignsCommand extends $Command<ListCampaignsCommandInput, ListCampaignsCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: ListCampaignsCommandInput;
     constructor(input: ListCampaignsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCampaignsCommandInput, ListCampaignsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface ListDatasetExportJobsCommandInput extends ListDatasetExportJobs
 }
 export interface ListDatasetExportJobsCommandOutput extends ListDatasetExportJobsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of dataset export jobs that use the given dataset. When a dataset is not
- *       specified, all the dataset export jobs associated with the account are listed. The response
- *       provides the properties for each dataset export job, including the Amazon Resource Name (ARN).
- *       For more information on dataset export jobs, see <a>CreateDatasetExportJob</a>. For
- *       more information on datasets, see <a>CreateDataset</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, ListDatasetExportJobsCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, ListDatasetExportJobsCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new ListDatasetExportJobsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDatasetExportJobsCommandInput} for command's `input` shape.
- * @see {@link ListDatasetExportJobsCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDatasetExportJobsCommand extends $Command<ListDatasetExportJobsCommandInput, ListDatasetExportJobsCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: ListDatasetExportJobsCommandInput;
     constructor(input: ListDatasetExportJobsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDatasetExportJobsCommandInput, ListDatasetExportJobsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface ListDatasetGroupsCommandInput extends ListDatasetGroupsRequest
 }
 export interface ListDatasetGroupsCommandOutput extends ListDatasetGroupsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns a list of dataset groups. The response provides the properties for each dataset
- *       group, including the Amazon Resource Name (ARN). For more information on dataset groups, see
- *         <a>CreateDatasetGroup</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, ListDatasetGroupsCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, ListDatasetGroupsCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new ListDatasetGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDatasetGroupsCommandInput} for command's `input` shape.
- * @see {@link ListDatasetGroupsCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDatasetGroupsCommand extends $Command<ListDatasetGroupsCommandInput, ListDatasetGroupsCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: ListDatasetGroupsCommandInput;
     constructor(input: ListDatasetGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDatasetGroupsCommandInput, ListDatasetGroupsCommandOutput>;
     private serialize;
     private deserialize;