@aws-sdk/client-personalize 3.36.0 → 3.39.0

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

@@ -6,74 +6,11 @@ export interface CreateEventTrackerCommandInput extends CreateEventTrackerReques
 }
 export interface CreateEventTrackerCommandOutput extends CreateEventTrackerResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an event tracker that you use when adding event data to a specified dataset
- *       group using the
- *       <a href="https://docs.aws.amazon.com/personalize/latest/dg/API_UBS_PutEvents.html">PutEvents</a> API.</p>
- *          <note>
- *             <p>Only one event tracker can be associated with a dataset group. You will get
- *         an error if you call <code>CreateEventTracker</code> using the same dataset group as an
- *         existing event tracker.</p>
- *          </note>
- *          <p>When you create an event tracker, the response includes a tracking ID, which you pass as a parameter when you use the
- *       <a href="https://docs.aws.amazon.com/personalize/latest/dg/API_UBS_PutEvents.html">PutEvents</a> operation.
- *       Amazon Personalize then appends the event data to the Interactions dataset of the dataset group you specify
- *       in your event tracker.
- *     </p>
- *          <p>The event tracker 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>To get the status of the event tracker, call <a>DescribeEventTracker</a>.</p>
- *          <note>
- *             <p>The event tracker must be in the ACTIVE state before using the tracking ID.</p>
- *          </note>
- *          <p class="title">
- *             <b>Related APIs</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a>ListEventTrackers</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DescribeEventTracker</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DeleteEventTracker</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, CreateEventTrackerCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, CreateEventTrackerCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new CreateEventTrackerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateEventTrackerCommandInput} for command's `input` shape.
- * @see {@link CreateEventTrackerCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateEventTrackerCommand extends $Command<CreateEventTrackerCommandInput, CreateEventTrackerCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: CreateEventTrackerCommandInput;
     constructor(input: CreateEventTrackerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEventTrackerCommandInput, CreateEventTrackerCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,54 +6,11 @@ export interface CreateSchemaCommandInput extends CreateSchemaRequest {
 }
 export interface CreateSchemaCommandOutput extends CreateSchemaResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an Amazon Personalize schema from the specified schema string. The schema you create
- *       must be in Avro JSON format.</p>
- *          <p>Amazon Personalize recognizes three schema variants. Each schema is associated with a dataset
- *       type and has a set of required field and keywords.
- *       You specify a schema when you call <a>CreateDataset</a>.</p>
- *
- *          <p class="title">
- *             <b>Related APIs</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a>ListSchemas</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DescribeSchema</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DeleteSchema</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, CreateSchemaCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, CreateSchemaCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new CreateSchemaCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSchemaCommandInput} for command's `input` shape.
- * @see {@link CreateSchemaCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSchemaCommand extends $Command<CreateSchemaCommandInput, CreateSchemaCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: CreateSchemaCommandInput;
     constructor(input: CreateSchemaCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSchemaCommandInput, CreateSchemaCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,101 +6,11 @@ export interface CreateSolutionCommandInput extends CreateSolutionRequest {
 }
 export interface CreateSolutionCommandOutput extends CreateSolutionResponse, __MetadataBearer {
 }
-/**
- * <p>Creates the configuration for training a model. A trained model is known as
- *       a solution. After the configuration is created, you train the model (create a solution)
- *       by calling the <a>CreateSolutionVersion</a> operation. Every time you call
- *       <code>CreateSolutionVersion</code>, a new version of the solution is created.</p>
- *          <p>After creating a solution version, you check its accuracy by calling
- *       <a>GetSolutionMetrics</a>. When you are satisfied with the version, you
- *       deploy it using <a>CreateCampaign</a>. The campaign provides recommendations
- *       to a client through the
- *       <a href="https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html">GetRecommendations</a> API.</p>
- *          <p>To train a model, Amazon Personalize requires training data and a recipe. The training data
- *       comes from the dataset group that you provide in the request. A recipe specifies
- *       the training algorithm and a feature transformation. You can specify one of the predefined
- *       recipes provided by Amazon Personalize. Alternatively, you can specify
- *       <code>performAutoML</code> and Amazon Personalize will analyze your data and select the
- *       optimum USER_PERSONALIZATION recipe for you.</p>
- *          <note>
- *             <p>Amazon Personalize doesn't support configuring the <code>hpoObjective</code>
- *         for solution hyperparameter optimization at this time.</p>
- *          </note>
- *          <p>
- *             <b>Status</b>
- *          </p>
- *          <p>A solution 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>To get the status of the solution, call <a>DescribeSolution</a>. Wait
- *       until the status shows as ACTIVE before calling <code>CreateSolutionVersion</code>.</p>
- *
- *
- *
- *          <p class="title">
- *             <b>Related APIs</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a>ListSolutions</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>CreateSolutionVersion</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DescribeSolution</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DeleteSolution</a>
- *                </p>
- *             </li>
- *          </ul>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a>ListSolutionVersions</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DescribeSolutionVersion</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, CreateSolutionCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, CreateSolutionCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new CreateSolutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSolutionCommandInput} for command's `input` shape.
- * @see {@link CreateSolutionCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSolutionCommand extends $Command<CreateSolutionCommandInput, CreateSolutionCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: CreateSolutionCommandInput;
     constructor(input: CreateSolutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSolutionCommandInput, CreateSolutionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,96 +6,11 @@ export interface CreateSolutionVersionCommandInput extends CreateSolutionVersion
 }
 export interface CreateSolutionVersionCommandOutput extends CreateSolutionVersionResponse, __MetadataBearer {
 }
-/**
- * <p>Trains or retrains an active solution. A solution is created using the <a>CreateSolution</a> operation and must be in the ACTIVE state before calling
- *         <code>CreateSolutionVersion</code>. A new version of the solution is created every time you
- *       call this operation.</p>
- *          <p>
- *             <b>Status</b>
- *          </p>
- *          <p>A solution version can be in one of the following states:</p>
- *          <ul>
- *             <li>
- *                <p>CREATE PENDING</p>
- *             </li>
- *             <li>
- *                <p>CREATE IN_PROGRESS</p>
- *             </li>
- *             <li>
- *                <p>ACTIVE</p>
- *             </li>
- *             <li>
- *                <p>CREATE FAILED</p>
- *             </li>
- *             <li>
- *                <p>CREATE STOPPING</p>
- *             </li>
- *             <li>
- *                <p>CREATE STOPPED</p>
- *             </li>
- *          </ul>
- *          <p>To get the status of the version, call <a>DescribeSolutionVersion</a>. Wait
- *       until the status shows as ACTIVE before calling <code>CreateCampaign</code>.</p>
- *          <p>If the status shows as CREATE FAILED, the response includes a <code>failureReason</code>
- *       key, which describes why the job failed.</p>
- *          <p class="title">
- *             <b>Related APIs</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a>ListSolutionVersions</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DescribeSolutionVersion</a>
- *                </p>
- *             </li>
- *          </ul>
- *          <ul>
- *             <li>
- *                <p>
- *                   <a>ListSolutions</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>CreateSolution</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DescribeSolution</a>
- *                </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <a>DeleteSolution</a>
- *                </p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, CreateSolutionVersionCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, CreateSolutionVersionCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new CreateSolutionVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSolutionVersionCommandInput} for command's `input` shape.
- * @see {@link CreateSolutionVersionCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateSolutionVersionCommand extends $Command<CreateSolutionVersionCommandInput, CreateSolutionVersionCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: CreateSolutionVersionCommandInput;
     constructor(input: CreateSolutionVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSolutionVersionCommandInput, CreateSolutionVersionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface DeleteCampaignCommandInput extends DeleteCampaignRequest {
 }
 export interface DeleteCampaignCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Removes a campaign by deleting the solution deployment. The solution that
- *       the campaign is based on is not deleted and can be redeployed when needed. A deleted campaign can no
- *       longer be specified in a
- *       <a href="https://docs.aws.amazon.com/personalize/latest/dg/API_RS_GetRecommendations.html">GetRecommendations</a>
- *       request.
- *       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, DeleteCampaignCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DeleteCampaignCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DeleteCampaignCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteCampaignCommandInput} for command's `input` shape.
- * @see {@link DeleteCampaignCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteCampaignCommand extends $Command<DeleteCampaignCommandInput, DeleteCampaignCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DeleteCampaignCommandInput;
     constructor(input: DeleteCampaignCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCampaignCommandInput, DeleteCampaignCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteDatasetCommandInput extends DeleteDatasetRequest {
 }
 export interface DeleteDatasetCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a dataset. You can't delete a dataset if an associated
- *         <code>DatasetImportJob</code> or <code>SolutionVersion</code> is in the CREATE PENDING or IN
- *       PROGRESS state. 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, DeleteDatasetCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DeleteDatasetCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(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 PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDatasetCommand extends $Command<DeleteDatasetCommandInput, DeleteDatasetCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DeleteDatasetCommandInput;
     constructor(input: DeleteDatasetCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDatasetCommandInput, DeleteDatasetCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface DeleteDatasetGroupCommandInput extends DeleteDatasetGroupReques
 }
 export interface DeleteDatasetGroupCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a dataset group. Before you delete a dataset group, you must delete the
- *       following:</p>
- *          <ul>
- *             <li>
- *                <p>All associated event trackers.</p>
- *             </li>
- *             <li>
- *                <p>All associated solutions.</p>
- *             </li>
- *             <li>
- *                <p>All datasets in the dataset group.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { PersonalizeClient, DeleteDatasetGroupCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DeleteDatasetGroupCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DeleteDatasetGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDatasetGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteDatasetGroupCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDatasetGroupCommand extends $Command<DeleteDatasetGroupCommandInput, DeleteDatasetGroupCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DeleteDatasetGroupCommandInput;
     constructor(input: DeleteDatasetGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDatasetGroupCommandInput, DeleteDatasetGroupCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteEventTrackerCommandInput extends DeleteEventTrackerReques
 }
 export interface DeleteEventTrackerCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the event tracker. Does not delete the event-interactions dataset from
- *         the associated dataset group. 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, DeleteEventTrackerCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DeleteEventTrackerCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DeleteEventTrackerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEventTrackerCommandInput} for command's `input` shape.
- * @see {@link DeleteEventTrackerCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteEventTrackerCommand extends $Command<DeleteEventTrackerCommandInput, DeleteEventTrackerCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DeleteEventTrackerCommandInput;
     constructor(input: DeleteEventTrackerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEventTrackerCommandInput, DeleteEventTrackerCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,31 +6,11 @@ export interface DeleteSchemaCommandInput extends DeleteSchemaRequest {
 }
 export interface DeleteSchemaCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a schema. Before deleting a schema, you must delete all
- *       datasets referencing the 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, DeleteSchemaCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DeleteSchemaCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DeleteSchemaCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteSchemaCommandInput} for command's `input` shape.
- * @see {@link DeleteSchemaCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteSchemaCommand extends $Command<DeleteSchemaCommandInput, DeleteSchemaCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DeleteSchemaCommandInput;
     constructor(input: DeleteSchemaCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSchemaCommandInput, DeleteSchemaCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface DeleteSolutionCommandInput extends DeleteSolutionRequest {
 }
 export interface DeleteSolutionCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes all versions of a solution and the <code>Solution</code> object itself.
- *       Before deleting a solution, you must delete all campaigns based on
- *       the solution. To determine what campaigns are using the solution, call
- *       <a>ListCampaigns</a> and supply the Amazon Resource Name (ARN) of the solution.
- *       You can't delete a solution if an associated <code>SolutionVersion</code> is in the
- *       CREATE PENDING or IN PROGRESS state.
- *       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, DeleteSolutionCommand } from "@aws-sdk/client-personalize"; // ES Modules import
- * // const { PersonalizeClient, DeleteSolutionCommand } = require("@aws-sdk/client-personalize"); // CommonJS import
- * const client = new PersonalizeClient(config);
- * const command = new DeleteSolutionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteSolutionCommandInput} for command's `input` shape.
- * @see {@link DeleteSolutionCommandOutput} for command's `response` shape.
- * @see {@link PersonalizeClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteSolutionCommand extends $Command<DeleteSolutionCommandInput, DeleteSolutionCommandOutput, PersonalizeClientResolvedConfig> {
     readonly input: DeleteSolutionCommandInput;
     constructor(input: DeleteSolutionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: PersonalizeClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSolutionCommandInput, DeleteSolutionCommandOutput>;
     private serialize;
     private deserialize;

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

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