@aws-sdk/client-kendra 3.35.0 → 3.38.0

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

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

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

@@ -6,34 +6,11 @@ export interface DescribePrincipalMappingCommandInput extends DescribePrincipalM
 }
 export interface DescribePrincipalMappingCommandOutput extends DescribePrincipalMappingResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the processing of <code>PUT</code> and <code>DELETE</code> actions
- *             for mapping users to their groups. This includes information on the status of
- *             actions currently processing or yet to be processed, when actions were last updated,
- *             when actions were received by Amazon Kendra, the latest action that should process
- *             and apply after other actions, and useful error messages if an action could
- *             not be processed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, DescribePrincipalMappingCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, DescribePrincipalMappingCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new DescribePrincipalMappingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribePrincipalMappingCommandInput} for command's `input` shape.
- * @see {@link DescribePrincipalMappingCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribePrincipalMappingCommand extends $Command<DescribePrincipalMappingCommandInput, DescribePrincipalMappingCommandOutput, KendraClientResolvedConfig> {
     readonly input: DescribePrincipalMappingCommandInput;
     constructor(input: DescribePrincipalMappingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePrincipalMappingCommandInput, DescribePrincipalMappingCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeQuerySuggestionsBlockListCommandInput extends DescribeQ
 }
 export interface DescribeQuerySuggestionsBlockListCommandOutput extends DescribeQuerySuggestionsBlockListResponse, __MetadataBearer {
 }
-/**
- * <p>Describes a block list used for query suggestions for an index.</p>
- *         <p>This is used to check the current settings that are applied to a
- *             block list.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, DescribeQuerySuggestionsBlockListCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, DescribeQuerySuggestionsBlockListCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new DescribeQuerySuggestionsBlockListCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeQuerySuggestionsBlockListCommandInput} for command's `input` shape.
- * @see {@link DescribeQuerySuggestionsBlockListCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeQuerySuggestionsBlockListCommand extends $Command<DescribeQuerySuggestionsBlockListCommandInput, DescribeQuerySuggestionsBlockListCommandOutput, KendraClientResolvedConfig> {
     readonly input: DescribeQuerySuggestionsBlockListCommandInput;
     constructor(input: DescribeQuerySuggestionsBlockListCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeQuerySuggestionsBlockListCommandInput, DescribeQuerySuggestionsBlockListCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeQuerySuggestionsConfigCommandInput extends DescribeQuer
 }
 export interface DescribeQuerySuggestionsConfigCommandOutput extends DescribeQuerySuggestionsConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Describes the settings of query suggestions for an index.</p>
- *         <p>This is used to check the current settings applied
- *             to query suggestions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, DescribeQuerySuggestionsConfigCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, DescribeQuerySuggestionsConfigCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new DescribeQuerySuggestionsConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeQuerySuggestionsConfigCommandInput} for command's `input` shape.
- * @see {@link DescribeQuerySuggestionsConfigCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeQuerySuggestionsConfigCommand extends $Command<DescribeQuerySuggestionsConfigCommandInput, DescribeQuerySuggestionsConfigCommandOutput, KendraClientResolvedConfig> {
     readonly input: DescribeQuerySuggestionsConfigCommandInput;
     constructor(input: DescribeQuerySuggestionsConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeQuerySuggestionsConfigCommandInput, DescribeQuerySuggestionsConfigCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeThesaurusCommandInput extends DescribeThesaurusRequest
 }
 export interface DescribeThesaurusCommandOutput extends DescribeThesaurusResponse, __MetadataBearer {
 }
-/**
- * <p>Describes 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, DescribeThesaurusCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, DescribeThesaurusCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new DescribeThesaurusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeThesaurusCommandInput} for command's `input` shape.
- * @see {@link DescribeThesaurusCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeThesaurusCommand extends $Command<DescribeThesaurusCommandInput, DescribeThesaurusCommandOutput, KendraClientResolvedConfig> {
     readonly input: DescribeThesaurusCommandInput;
     constructor(input: DescribeThesaurusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeThesaurusCommandInput, DescribeThesaurusCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface ListGroupsOlderThanOrderingIdCommandInput extends ListGroupsOld
 }
 export interface ListGroupsOlderThanOrderingIdCommandOutput extends ListGroupsOlderThanOrderingIdResponse, __MetadataBearer {
 }
-/**
- * <p>Provides a list of groups that are mapped to users before a
- *             given ordering or timestamp identifier.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, ListGroupsOlderThanOrderingIdCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, ListGroupsOlderThanOrderingIdCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new ListGroupsOlderThanOrderingIdCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListGroupsOlderThanOrderingIdCommandInput} for command's `input` shape.
- * @see {@link ListGroupsOlderThanOrderingIdCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListGroupsOlderThanOrderingIdCommand extends $Command<ListGroupsOlderThanOrderingIdCommandInput, ListGroupsOlderThanOrderingIdCommandOutput, KendraClientResolvedConfig> {
     readonly input: ListGroupsOlderThanOrderingIdCommandInput;
     constructor(input: ListGroupsOlderThanOrderingIdCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListGroupsOlderThanOrderingIdCommandInput, ListGroupsOlderThanOrderingIdCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,32 +6,11 @@ export interface ListQuerySuggestionsBlockListsCommandInput extends ListQuerySug
 }
 export interface ListQuerySuggestionsBlockListsCommandOutput extends ListQuerySuggestionsBlockListsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the block lists used for query suggestions for an index.</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, ListQuerySuggestionsBlockListsCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, ListQuerySuggestionsBlockListsCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new ListQuerySuggestionsBlockListsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListQuerySuggestionsBlockListsCommandInput} for command's `input` shape.
- * @see {@link ListQuerySuggestionsBlockListsCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListQuerySuggestionsBlockListsCommand extends $Command<ListQuerySuggestionsBlockListsCommandInput, ListQuerySuggestionsBlockListsCommandOutput, KendraClientResolvedConfig> {
     readonly input: ListQuerySuggestionsBlockListsCommandInput;
     constructor(input: ListQuerySuggestionsBlockListsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListQuerySuggestionsBlockListsCommandInput, ListQuerySuggestionsBlockListsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a list of tags associated with a specified resource. Indexes,
- *       FAQs, and data sources can have tags associated with them.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, ListTagsForResourceCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, ListTagsForResourceCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, KendraClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,42 +6,11 @@ export interface PutPrincipalMappingCommandInput extends PutPrincipalMappingRequ
 }
 export interface PutPrincipalMappingCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Maps users to their groups. You can also map sub groups to groups.
- *             For example, the group "Company Intellectual Property Teams" includes
- *             sub groups "Research" and "Engineering". These sub groups include their
- *             own list of users or people who work in these teams. Only users who work
- *             in research and engineering, and therefore belong in the intellectual
- *             property group, can see top-secret company documents in their search
- *             results. </p>
- *         <p>You map users to their groups when you want to filter search results
- *             for different users based on their group’s access to documents. For more
- *             information on filtering search results for different users, see
- *             <a href="https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html">Filtering
- *                 on user context</a>.</p>
- *         <p>If more than five <code>PUT</code> actions for a group are currently
- *             processing, a validation exception is thrown.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, PutPrincipalMappingCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, PutPrincipalMappingCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new PutPrincipalMappingCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutPrincipalMappingCommandInput} for command's `input` shape.
- * @see {@link PutPrincipalMappingCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutPrincipalMappingCommand extends $Command<PutPrincipalMappingCommandInput, PutPrincipalMappingCommandOutput, KendraClientResolvedConfig> {
     readonly input: PutPrincipalMappingCommandInput;
     constructor(input: PutPrincipalMappingCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutPrincipalMappingCommandInput, PutPrincipalMappingCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,50 +6,11 @@ export interface QueryCommandInput extends QueryRequest {
 }
 export interface QueryCommandOutput extends QueryResult, __MetadataBearer {
 }
-/**
- * <p>Searches an active index. Use this API to search your documents
- *          using query. The <code>Query</code> operation enables to do faceted
- *          search and to filter results based on document attributes.</p>
- *          <p>It also enables you to provide user context that Amazon Kendra uses
- *          to enforce document access control in the search results. </p>
- *          <p>Amazon Kendra searches your index for text content and question and
- *          answer (FAQ) content. By default the response contains three types of
- *          results.</p>
- *          <ul>
- *             <li>
- *                <p>Relevant passages</p>
- *             </li>
- *             <li>
- *                <p>Matching FAQs</p>
- *             </li>
- *             <li>
- *                <p>Relevant documents</p>
- *             </li>
- *          </ul>
- *          <p>You can specify that the query return only one type of result using
- *          the <code>QueryResultTypeConfig</code> parameter.</p>
- *          <p>Each query returns the 100 most relevant results. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, QueryCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, QueryCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new QueryCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link QueryCommandInput} for command's `input` shape.
- * @see {@link QueryCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class QueryCommand extends $Command<QueryCommandInput, QueryCommandOutput, KendraClientResolvedConfig> {
     readonly input: QueryCommandInput;
     constructor(input: QueryCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<QueryCommandInput, QueryCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface StartDataSourceSyncJobCommandInput extends StartDataSourceSyncJ
 }
 export interface StartDataSourceSyncJobCommandOutput extends StartDataSourceSyncJobResponse, __MetadataBearer {
 }
-/**
- * <p>Starts a synchronization job for a data source. If a synchronization
- *       job is already in progress, Amazon Kendra returns a
- *         <code>ResourceInUseException</code> exception.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KendraClient, StartDataSourceSyncJobCommand } from "@aws-sdk/client-kendra"; // ES Modules import
- * // const { KendraClient, StartDataSourceSyncJobCommand } = require("@aws-sdk/client-kendra"); // CommonJS import
- * const client = new KendraClient(config);
- * const command = new StartDataSourceSyncJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartDataSourceSyncJobCommandInput} for command's `input` shape.
- * @see {@link StartDataSourceSyncJobCommandOutput} for command's `response` shape.
- * @see {@link KendraClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartDataSourceSyncJobCommand extends $Command<StartDataSourceSyncJobCommandInput, StartDataSourceSyncJobCommandOutput, KendraClientResolvedConfig> {
     readonly input: StartDataSourceSyncJobCommandInput;
     constructor(input: StartDataSourceSyncJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KendraClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartDataSourceSyncJobCommandInput, StartDataSourceSyncJobCommandOutput>;
     private serialize;
     private deserialize;

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

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