@aws-sdk/client-kendra 3.35.0 → 3.38.0

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

@@ -6,33 +6,11 @@ export interface BatchDeleteDocumentCommandInput extends BatchDeleteDocumentRequ
 }
 export interface BatchDeleteDocumentCommandOutput extends BatchDeleteDocumentResponse, __MetadataBearer {
 }
-/**
- * <p>Removes one or more documents from an index. The documents must have
- *       been added with the <code>BatchPutDocument</code> operation.</p>
- *          <p>The documents are deleted asynchronously. You can see the progress of
- *       the deletion by using Amazon Web Services CloudWatch. Any error messages related to the
- *       processing of the batch are sent to you CloudWatch log.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, BatchDeleteDocumentCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, BatchDeleteDocumentCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new BatchDeleteDocumentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link BatchDeleteDocumentCommandInput} for command's `input` shape.
- * @see {@link BatchDeleteDocumentCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class BatchDeleteDocumentCommand extends $Command<BatchDeleteDocumentCommandInput, BatchDeleteDocumentCommandOutput, KendraClientResolvedConfig> {
     readonly input: BatchDeleteDocumentCommandInput;
     constructor(input: BatchDeleteDocumentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchDeleteDocumentCommandInput, BatchDeleteDocumentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface BatchGetDocumentStatusCommandInput extends BatchGetDocumentStat
 }
 export interface BatchGetDocumentStatusCommandOutput extends BatchGetDocumentStatusResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the indexing status for one or more documents submitted
- *             with the <a href="https://docs.aws.amazon.com/kendra/latest/dg/API_BatchPutDocument.html">
- *                 BatchPutDocument</a> operation.</p>
- *         <p>When you use the <code>BatchPutDocument</code> operation,
- *             documents are indexed asynchronously. You can use the
- *                 <code>BatchGetDocumentStatus</code> operation to get the current
- *             status of a list of documents so that you can determine if they have
- *             been successfully indexed.</p>
- *         <p>You can also use the <code>BatchGetDocumentStatus</code> operation
- *             to check the status of the <a href="https://docs.aws.amazon.com/kendra/latest/dg/API_BatchDeleteDocument.html">
- *                 BatchDeleteDocument</a> operation. When a document is
- *             deleted from the index, Amazon Kendra returns <code>NOT_FOUND</code> as the
- *             status.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, BatchGetDocumentStatusCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, BatchGetDocumentStatusCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new BatchGetDocumentStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link BatchGetDocumentStatusCommandInput} for command's `input` shape.
- * @see {@link BatchGetDocumentStatusCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class BatchGetDocumentStatusCommand extends $Command<BatchGetDocumentStatusCommandInput, BatchGetDocumentStatusCommandOutput, KendraClientResolvedConfig> {
     readonly input: BatchGetDocumentStatusCommandInput;
     constructor(input: BatchGetDocumentStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchGetDocumentStatusCommandInput, BatchGetDocumentStatusCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface BatchPutDocumentCommandInput extends BatchPutDocumentRequest {
 }
 export interface BatchPutDocumentCommandOutput extends BatchPutDocumentResponse, __MetadataBearer {
 }
-/**
- * <p>Adds one or more documents to an index.</p>
- *          <p>The <code>BatchPutDocument</code> operation enables you to ingest
- *       inline documents or a set of documents stored in an Amazon S3 bucket. Use
- *       this operation to ingest your text and unstructured text into an index,
- *       add custom attributes to the documents, and to attach an access control
- *       list to the documents added to the index.</p>
- *          <p>The documents are indexed asynchronously. You can see the progress of
- *       the batch using Amazon Web Services CloudWatch. Any error messages related to processing
- *       the batch are sent to your Amazon Web Services CloudWatch log.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, BatchPutDocumentCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, BatchPutDocumentCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new BatchPutDocumentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link BatchPutDocumentCommandInput} for command's `input` shape.
- * @see {@link BatchPutDocumentCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class BatchPutDocumentCommand extends $Command<BatchPutDocumentCommandInput, BatchPutDocumentCommandOutput, KendraClientResolvedConfig> {
     readonly input: BatchPutDocumentCommandInput;
     constructor(input: BatchPutDocumentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<BatchPutDocumentCommandInput, BatchPutDocumentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface ClearQuerySuggestionsCommandInput extends ClearQuerySuggestions
 }
 export interface ClearQuerySuggestionsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Clears existing query suggestions from an index.</p>
- *         <p>This deletes existing suggestions only, not the queries
- *             in the query log. After you clear suggestions, Amazon Kendra learns
- *             new suggestions based on new queries added to the query log
- *             from the time you cleared suggestions. If you do not see any
- *             new suggestions, then please allow Amazon Kendra to collect
- *             enough queries to learn new suggestions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, ClearQuerySuggestionsCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, ClearQuerySuggestionsCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new ClearQuerySuggestionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ClearQuerySuggestionsCommandInput} for command's `input` shape.
- * @see {@link ClearQuerySuggestionsCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ClearQuerySuggestionsCommand extends $Command<ClearQuerySuggestionsCommandInput, ClearQuerySuggestionsCommandOutput, KendraClientResolvedConfig> {
     readonly input: ClearQuerySuggestionsCommandInput;
     constructor(input: ClearQuerySuggestionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ClearQuerySuggestionsCommandInput, ClearQuerySuggestionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface CreateDataSourceCommandInput extends CreateDataSourceRequest {
 }
 export interface CreateDataSourceCommandOutput extends CreateDataSourceResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a data source that you use to with an Amazon Kendra index. </p>
- *          <p>You specify a name, data source connector type and description for
- *       your data source. You also specify configuration information such as
- *       document metadata (author, source URI, and so on) and user context
- *       information.</p>
- *          <p>
- *             <code>CreateDataSource</code> is a synchronous operation. The
- *       operation returns 200 if the data source was successfully created.
- *       Otherwise, an exception is raised.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, CreateDataSourceCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, CreateDataSourceCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new CreateDataSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDataSourceCommandInput} for command's `input` shape.
- * @see {@link CreateDataSourceCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDataSourceCommand extends $Command<CreateDataSourceCommandInput, CreateDataSourceCommandOutput, KendraClientResolvedConfig> {
     readonly input: CreateDataSourceCommandInput;
     constructor(input: CreateDataSourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDataSourceCommandInput, CreateDataSourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateFaqCommandInput extends CreateFaqRequest {
 }
 export interface CreateFaqCommandOutput extends CreateFaqResponse, __MetadataBearer {
 }
-/**
- * <p>Creates an new set of frequently asked question (FAQ) questions and answers.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, CreateFaqCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, CreateFaqCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new CreateFaqCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateFaqCommandInput} for command's `input` shape.
- * @see {@link CreateFaqCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateFaqCommand extends $Command<CreateFaqCommandInput, CreateFaqCommandOutput, KendraClientResolvedConfig> {
     readonly input: CreateFaqCommandInput;
     constructor(input: CreateFaqCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFaqCommandInput, CreateFaqCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface CreateIndexCommandInput extends CreateIndexRequest {
 }
 export interface CreateIndexCommandOutput extends CreateIndexResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new Amazon Kendra index. Index creation is an asynchronous
- *       operation. To determine if index creation has completed, check the
- *         <code>Status</code> field returned from a call to
- *         <code>DescribeIndex</code>. The <code>Status</code> field is set to
- *         <code>ACTIVE</code> when the index is ready to use.</p>
- *          <p>Once the index is active you can index your documents using the
- *         <code>BatchPutDocument</code> operation or using one of the supported
- *       data sources. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, CreateIndexCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, CreateIndexCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new CreateIndexCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateIndexCommandInput} for command's `input` shape.
- * @see {@link CreateIndexCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateIndexCommand extends $Command<CreateIndexCommandInput, CreateIndexCommandOutput, KendraClientResolvedConfig> {
     readonly input: CreateIndexCommandInput;
     constructor(input: CreateIndexCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateIndexCommandInput, CreateIndexCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface CreateQuerySuggestionsBlockListCommandInput extends CreateQuery
 }
 export interface CreateQuerySuggestionsBlockListCommandOutput extends CreateQuerySuggestionsBlockListResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a block list to exlcude certain queries from suggestions.</p>
- *         <p>Any query that contains words or phrases specified in the block
- *             list is blocked or filtered out from being shown as a suggestion.</p>
- *         <p>You need to provide the file location of your block list text file
- *             in your S3 bucket. In your text file, enter each block word or phrase
- *             on a separate line.</p>
- *         <p>For information on the current quota limits for block lists, see
- *             <a href="https://docs.aws.amazon.com/kendra/latest/dg/quotas.html">Quotas
- *                 for Amazon Kendra</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, CreateQuerySuggestionsBlockListCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, CreateQuerySuggestionsBlockListCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new CreateQuerySuggestionsBlockListCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateQuerySuggestionsBlockListCommandInput} for command's `input` shape.
- * @see {@link CreateQuerySuggestionsBlockListCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateQuerySuggestionsBlockListCommand extends $Command<CreateQuerySuggestionsBlockListCommandInput, CreateQuerySuggestionsBlockListCommandOutput, KendraClientResolvedConfig> {
     readonly input: CreateQuerySuggestionsBlockListCommandInput;
     constructor(input: CreateQuerySuggestionsBlockListCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateQuerySuggestionsBlockListCommandInput, CreateQuerySuggestionsBlockListCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateThesaurusCommandInput extends CreateThesaurusRequest {
 }
 export interface CreateThesaurusCommandOutput extends CreateThesaurusResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a thesaurus for an index. The thesaurus
- *       contains a list of synonyms in Solr format.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, CreateThesaurusCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, CreateThesaurusCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new CreateThesaurusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateThesaurusCommandInput} for command's `input` shape.
- * @see {@link CreateThesaurusCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateThesaurusCommand extends $Command<CreateThesaurusCommandInput, CreateThesaurusCommandOutput, KendraClientResolvedConfig> {
     readonly input: CreateThesaurusCommandInput;
     constructor(input: CreateThesaurusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateThesaurusCommandInput, CreateThesaurusCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,33 +6,11 @@ export interface DeleteDataSourceCommandInput extends DeleteDataSourceRequest {
 }
 export interface DeleteDataSourceCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes an Amazon Kendra data source. An exception is not thrown if the
- *       data source is already being deleted. While the data source is being
- *       deleted, the <code>Status</code> field returned by a call to the
- *         <code>DescribeDataSource</code> operation is set to
- *         <code>DELETING</code>. For more information, see <a href="https://docs.aws.amazon.com/kendra/latest/dg/delete-data-source.html">Deleting Data Sources</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, DeleteDataSourceCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, DeleteDataSourceCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new DeleteDataSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDataSourceCommandInput} for command's `input` shape.
- * @see {@link DeleteDataSourceCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDataSourceCommand extends $Command<DeleteDataSourceCommandInput, DeleteDataSourceCommandOutput, KendraClientResolvedConfig> {
     readonly input: DeleteDataSourceCommandInput;
     constructor(input: DeleteDataSourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDataSourceCommandInput, DeleteDataSourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,33 +6,11 @@ export interface DeleteIndexCommandInput extends DeleteIndexRequest {
 }
 export interface DeleteIndexCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes an existing Amazon Kendra index. An exception is not thrown if
- *       the index is already being deleted. While the index is being deleted, the
- *         <code>Status</code> field returned by a call to the
- *         <code>DescribeIndex</code> operation is set to
- *       <code>DELETING</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, DeleteIndexCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, DeleteIndexCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new DeleteIndexCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteIndexCommandInput} for command's `input` shape.
- * @see {@link DeleteIndexCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteIndexCommand extends $Command<DeleteIndexCommandInput, DeleteIndexCommandOutput, KendraClientResolvedConfig> {
     readonly input: DeleteIndexCommandInput;
     constructor(input: DeleteIndexCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteIndexCommandInput, DeleteIndexCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,40 +6,11 @@ export interface DeletePrincipalMappingCommandInput extends DeletePrincipalMappi
 }
 export interface DeletePrincipalMappingCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a group so that all users and sub groups that belong to the group can
- *             no longer access documents only available to that group.</p>
- *         <p>For example, after deleting the group "Summer Interns", all interns who
- *             belonged to that group no longer see intern-only documents in their search
- *             results.</p>
- *         <p>If you want to delete or replace users or sub groups of a group, you need to
- *             use the <code>PutPrincipalMapping</code> operation. For example, if a user in
- *             the group "Engineering" leaves the engineering team and another user takes
- *             their place, you provide an updated list of users or sub groups that belong
- *             to the "Engineering" group when calling <code>PutPrincipalMapping</code>. You
- *             can update your internal list of users or sub groups and input this list
- *             when calling <code>PutPrincipalMapping</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, DeletePrincipalMappingCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, DeletePrincipalMappingCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new DeletePrincipalMappingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeletePrincipalMappingCommandInput} for command's `input` shape.
- * @see {@link DeletePrincipalMappingCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeletePrincipalMappingCommand extends $Command<DeletePrincipalMappingCommandInput, DeletePrincipalMappingCommandOutput, KendraClientResolvedConfig> {
     readonly input: DeletePrincipalMappingCommandInput;
     constructor(input: DeletePrincipalMappingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeletePrincipalMappingCommandInput, DeletePrincipalMappingCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DeleteQuerySuggestionsBlockListCommandInput extends DeleteQuery
 }
 export interface DeleteQuerySuggestionsBlockListCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes a block list used for query suggestions for an index.</p>
- *         <p>A deleted block list might not take effect right away. Amazon Kendra
- *             needs to refresh the entire suggestions list to add back the
- *             queries that were previously blocked.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, DeleteQuerySuggestionsBlockListCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, DeleteQuerySuggestionsBlockListCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new DeleteQuerySuggestionsBlockListCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteQuerySuggestionsBlockListCommandInput} for command's `input` shape.
- * @see {@link DeleteQuerySuggestionsBlockListCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteQuerySuggestionsBlockListCommand extends $Command<DeleteQuerySuggestionsBlockListCommandInput, DeleteQuerySuggestionsBlockListCommandOutput, KendraClientResolvedConfig> {
     readonly input: DeleteQuerySuggestionsBlockListCommandInput;
     constructor(input: DeleteQuerySuggestionsBlockListCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteQuerySuggestionsBlockListCommandInput, DeleteQuerySuggestionsBlockListCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface DescribeDataSourceCommandInput extends DescribeDataSourceReques
 }
 export interface DescribeDataSourceCommandOutput extends DescribeDataSourceResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about a Amazon Kendra data source.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, DescribeDataSourceCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, DescribeDataSourceCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new DescribeDataSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDataSourceCommandInput} for command's `input` shape.
- * @see {@link DescribeDataSourceCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDataSourceCommand extends $Command<DescribeDataSourceCommandInput, DescribeDataSourceCommandOutput, KendraClientResolvedConfig> {
     readonly input: DescribeDataSourceCommandInput;
     constructor(input: DescribeDataSourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDataSourceCommandInput, DescribeDataSourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeFaqCommandInput extends DescribeFaqRequest {
 }
 export interface DescribeFaqCommandOutput extends DescribeFaqResponse, __MetadataBearer {
 }
-/**
- * <p>Gets information about an FAQ list.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, DescribeFaqCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, DescribeFaqCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new DescribeFaqCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeFaqCommandInput} for command's `input` shape.
- * @see {@link DescribeFaqCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeFaqCommand extends $Command<DescribeFaqCommandInput, DescribeFaqCommandOutput, KendraClientResolvedConfig> {
     readonly input: DescribeFaqCommandInput;
     constructor(input: DescribeFaqCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeFaqCommandInput, DescribeFaqCommandOutput>;
     private serialize;
     private deserialize;