@aws-sdk/client-elasticsearch-service 3.36.0 → 3.39.0

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

@@ -6,29 +6,11 @@ export interface AcceptInboundCrossClusterSearchConnectionCommandInput extends A
 }
 export interface AcceptInboundCrossClusterSearchConnectionCommandOutput extends AcceptInboundCrossClusterSearchConnectionResponse, __MetadataBearer {
 }
-/**
- * <p>Allows the destination domain owner to accept an inbound cross-cluster search connection request.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, AcceptInboundCrossClusterSearchConnectionCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, AcceptInboundCrossClusterSearchConnectionCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new AcceptInboundCrossClusterSearchConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AcceptInboundCrossClusterSearchConnectionCommandInput} for command's `input` shape.
- * @see {@link AcceptInboundCrossClusterSearchConnectionCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AcceptInboundCrossClusterSearchConnectionCommand extends $Command<AcceptInboundCrossClusterSearchConnectionCommandInput, AcceptInboundCrossClusterSearchConnectionCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: AcceptInboundCrossClusterSearchConnectionCommandInput;
     constructor(input: AcceptInboundCrossClusterSearchConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AcceptInboundCrossClusterSearchConnectionCommandInput, AcceptInboundCrossClusterSearchConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface AddTagsCommandInput extends AddTagsRequest {
 }
 export interface AddTagsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Attaches tags to an existing Elasticsearch domain. Tags are a set of case-sensitive key value pairs. An Elasticsearch domain may have up to 10 tags.  See <a href="http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-managedomains.html#es-managedomains-awsresorcetagging" target="_blank">
- *           Tagging Amazon Elasticsearch Service Domains for more information.</a></p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, AddTagsCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, AddTagsCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new AddTagsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AddTagsCommandInput} for command's `input` shape.
- * @see {@link AddTagsCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AddTagsCommand extends $Command<AddTagsCommandInput, AddTagsCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: AddTagsCommandInput;
     constructor(input: AddTagsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AddTagsCommandInput, AddTagsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface AssociatePackageCommandInput extends AssociatePackageRequest {
 }
 export interface AssociatePackageCommandOutput extends AssociatePackageResponse, __MetadataBearer {
 }
-/**
- * <p>Associates a package with an Amazon ES domain.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, AssociatePackageCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, AssociatePackageCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new AssociatePackageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AssociatePackageCommandInput} for command's `input` shape.
- * @see {@link AssociatePackageCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AssociatePackageCommand extends $Command<AssociatePackageCommandInput, AssociatePackageCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: AssociatePackageCommandInput;
     constructor(input: AssociatePackageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociatePackageCommandInput, AssociatePackageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CancelElasticsearchServiceSoftwareUpdateCommandInput extends Ca
 }
 export interface CancelElasticsearchServiceSoftwareUpdateCommandOutput extends CancelElasticsearchServiceSoftwareUpdateResponse, __MetadataBearer {
 }
-/**
- * <p>Cancels a scheduled service software update for an Amazon ES domain. You can only perform this operation before the <code>AutomatedUpdateDate</code> and when the <code>UpdateStatus</code> is in the <code>PENDING_UPDATE</code> state.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, CancelElasticsearchServiceSoftwareUpdateCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, CancelElasticsearchServiceSoftwareUpdateCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new CancelElasticsearchServiceSoftwareUpdateCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CancelElasticsearchServiceSoftwareUpdateCommandInput} for command's `input` shape.
- * @see {@link CancelElasticsearchServiceSoftwareUpdateCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CancelElasticsearchServiceSoftwareUpdateCommand extends $Command<CancelElasticsearchServiceSoftwareUpdateCommandInput, CancelElasticsearchServiceSoftwareUpdateCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: CancelElasticsearchServiceSoftwareUpdateCommandInput;
     constructor(input: CancelElasticsearchServiceSoftwareUpdateCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelElasticsearchServiceSoftwareUpdateCommandInput, CancelElasticsearchServiceSoftwareUpdateCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface CreateElasticsearchDomainCommandInput extends CreateElasticsear
 }
 export interface CreateElasticsearchDomainCommandOutput extends CreateElasticsearchDomainResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new Elasticsearch domain. For more information,
- *           see <a href="http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-createupdatedomains.html#es-createdomains" target="_blank">Creating Elasticsearch Domains</a> in the <i>Amazon Elasticsearch Service Developer Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, CreateElasticsearchDomainCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, CreateElasticsearchDomainCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new CreateElasticsearchDomainCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateElasticsearchDomainCommandInput} for command's `input` shape.
- * @see {@link CreateElasticsearchDomainCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateElasticsearchDomainCommand extends $Command<CreateElasticsearchDomainCommandInput, CreateElasticsearchDomainCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: CreateElasticsearchDomainCommandInput;
     constructor(input: CreateElasticsearchDomainCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateElasticsearchDomainCommandInput, CreateElasticsearchDomainCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateOutboundCrossClusterSearchConnectionCommandInput extends
 }
 export interface CreateOutboundCrossClusterSearchConnectionCommandOutput extends CreateOutboundCrossClusterSearchConnectionResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new cross-cluster search connection from a source domain to a destination domain.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, CreateOutboundCrossClusterSearchConnectionCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, CreateOutboundCrossClusterSearchConnectionCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new CreateOutboundCrossClusterSearchConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateOutboundCrossClusterSearchConnectionCommandInput} for command's `input` shape.
- * @see {@link CreateOutboundCrossClusterSearchConnectionCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateOutboundCrossClusterSearchConnectionCommand extends $Command<CreateOutboundCrossClusterSearchConnectionCommandInput, CreateOutboundCrossClusterSearchConnectionCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: CreateOutboundCrossClusterSearchConnectionCommandInput;
     constructor(input: CreateOutboundCrossClusterSearchConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateOutboundCrossClusterSearchConnectionCommandInput, CreateOutboundCrossClusterSearchConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreatePackageCommandInput extends CreatePackageRequest {
 }
 export interface CreatePackageCommandOutput extends CreatePackageResponse, __MetadataBearer {
 }
-/**
- * <p>Create a package for use with Amazon ES domains.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, CreatePackageCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, CreatePackageCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new CreatePackageCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreatePackageCommandInput} for command's `input` shape.
- * @see {@link CreatePackageCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreatePackageCommand extends $Command<CreatePackageCommandInput, CreatePackageCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: CreatePackageCommandInput;
     constructor(input: CreatePackageCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePackageCommandInput, CreatePackageCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteElasticsearchDomainCommandInput extends DeleteElasticsear
 }
 export interface DeleteElasticsearchDomainCommandOutput extends DeleteElasticsearchDomainResponse, __MetadataBearer {
 }
-/**
- * <p>Permanently deletes the specified Elasticsearch domain and all of its data. Once a domain is deleted, it cannot be recovered.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, DeleteElasticsearchDomainCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, DeleteElasticsearchDomainCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new DeleteElasticsearchDomainCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteElasticsearchDomainCommandInput} for command's `input` shape.
- * @see {@link DeleteElasticsearchDomainCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteElasticsearchDomainCommand extends $Command<DeleteElasticsearchDomainCommandInput, DeleteElasticsearchDomainCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: DeleteElasticsearchDomainCommandInput;
     constructor(input: DeleteElasticsearchDomainCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteElasticsearchDomainCommandInput, DeleteElasticsearchDomainCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -5,29 +5,11 @@ export interface DeleteElasticsearchServiceRoleCommandInput {
 }
 export interface DeleteElasticsearchServiceRoleCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Deletes the service-linked role that Elasticsearch Service uses to manage and maintain VPC domains. Role deletion will fail if any existing VPC domains use the role. You must delete any such Elasticsearch domains before deleting the role. See <a href="http://docs.aws.amazon.com/elasticsearch-service/latest/developerguide/es-vpc.html#es-enabling-slr" target="_blank">Deleting Elasticsearch Service Role</a> in <i>VPC Endpoints for Amazon Elasticsearch Service Domains</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, DeleteElasticsearchServiceRoleCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, DeleteElasticsearchServiceRoleCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new DeleteElasticsearchServiceRoleCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteElasticsearchServiceRoleCommandInput} for command's `input` shape.
- * @see {@link DeleteElasticsearchServiceRoleCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteElasticsearchServiceRoleCommand extends $Command<DeleteElasticsearchServiceRoleCommandInput, DeleteElasticsearchServiceRoleCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: DeleteElasticsearchServiceRoleCommandInput;
     constructor(input: DeleteElasticsearchServiceRoleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteElasticsearchServiceRoleCommandInput, DeleteElasticsearchServiceRoleCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteInboundCrossClusterSearchConnectionCommandInput extends D
 }
 export interface DeleteInboundCrossClusterSearchConnectionCommandOutput extends DeleteInboundCrossClusterSearchConnectionResponse, __MetadataBearer {
 }
-/**
- * <p>Allows the destination domain owner to delete an existing inbound cross-cluster search connection.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, DeleteInboundCrossClusterSearchConnectionCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, DeleteInboundCrossClusterSearchConnectionCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new DeleteInboundCrossClusterSearchConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteInboundCrossClusterSearchConnectionCommandInput} for command's `input` shape.
- * @see {@link DeleteInboundCrossClusterSearchConnectionCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteInboundCrossClusterSearchConnectionCommand extends $Command<DeleteInboundCrossClusterSearchConnectionCommandInput, DeleteInboundCrossClusterSearchConnectionCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: DeleteInboundCrossClusterSearchConnectionCommandInput;
     constructor(input: DeleteInboundCrossClusterSearchConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteInboundCrossClusterSearchConnectionCommandInput, DeleteInboundCrossClusterSearchConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteOutboundCrossClusterSearchConnectionCommandInput extends
 }
 export interface DeleteOutboundCrossClusterSearchConnectionCommandOutput extends DeleteOutboundCrossClusterSearchConnectionResponse, __MetadataBearer {
 }
-/**
- * <p>Allows the source domain owner to delete an existing outbound cross-cluster search connection.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, DeleteOutboundCrossClusterSearchConnectionCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, DeleteOutboundCrossClusterSearchConnectionCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new DeleteOutboundCrossClusterSearchConnectionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteOutboundCrossClusterSearchConnectionCommandInput} for command's `input` shape.
- * @see {@link DeleteOutboundCrossClusterSearchConnectionCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteOutboundCrossClusterSearchConnectionCommand extends $Command<DeleteOutboundCrossClusterSearchConnectionCommandInput, DeleteOutboundCrossClusterSearchConnectionCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: DeleteOutboundCrossClusterSearchConnectionCommandInput;
     constructor(input: DeleteOutboundCrossClusterSearchConnectionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteOutboundCrossClusterSearchConnectionCommandInput, DeleteOutboundCrossClusterSearchConnectionCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface DescribeDomainAutoTunesCommandInput extends DescribeDomainAutoT
 }
 export interface DescribeDomainAutoTunesCommandOutput extends DescribeDomainAutoTunesResponse, __MetadataBearer {
 }
-/**
- * <p>Provides scheduled Auto-Tune action details for the Elasticsearch domain, such as Auto-Tune action type, description, severity, and scheduled date.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, DescribeDomainAutoTunesCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, DescribeDomainAutoTunesCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new DescribeDomainAutoTunesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeDomainAutoTunesCommandInput} for command's `input` shape.
- * @see {@link DescribeDomainAutoTunesCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeDomainAutoTunesCommand extends $Command<DescribeDomainAutoTunesCommandInput, DescribeDomainAutoTunesCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: DescribeDomainAutoTunesCommandInput;
     constructor(input: DescribeDomainAutoTunesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeDomainAutoTunesCommandInput, DescribeDomainAutoTunesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeElasticsearchDomainCommandInput extends DescribeElastic
 }
 export interface DescribeElasticsearchDomainCommandOutput extends DescribeElasticsearchDomainResponse, __MetadataBearer {
 }
-/**
- * <p>Returns domain configuration information about the specified Elasticsearch domain, including the domain ID, domain endpoint, and domain ARN.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, DescribeElasticsearchDomainCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, DescribeElasticsearchDomainCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new DescribeElasticsearchDomainCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeElasticsearchDomainCommandInput} for command's `input` shape.
- * @see {@link DescribeElasticsearchDomainCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeElasticsearchDomainCommand extends $Command<DescribeElasticsearchDomainCommandInput, DescribeElasticsearchDomainCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: DescribeElasticsearchDomainCommandInput;
     constructor(input: DescribeElasticsearchDomainCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeElasticsearchDomainCommandInput, DescribeElasticsearchDomainCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeElasticsearchDomainConfigCommandInput extends DescribeE
 }
 export interface DescribeElasticsearchDomainConfigCommandOutput extends DescribeElasticsearchDomainConfigResponse, __MetadataBearer {
 }
-/**
- * <p>Provides cluster configuration information about the specified Elasticsearch domain, such as the state, creation date, update version, and update date for cluster options.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, DescribeElasticsearchDomainConfigCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, DescribeElasticsearchDomainConfigCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new DescribeElasticsearchDomainConfigCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeElasticsearchDomainConfigCommandInput} for command's `input` shape.
- * @see {@link DescribeElasticsearchDomainConfigCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeElasticsearchDomainConfigCommand extends $Command<DescribeElasticsearchDomainConfigCommandInput, DescribeElasticsearchDomainConfigCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: DescribeElasticsearchDomainConfigCommandInput;
     constructor(input: DescribeElasticsearchDomainConfigCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeElasticsearchDomainConfigCommandInput, DescribeElasticsearchDomainConfigCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeElasticsearchDomainsCommandInput extends DescribeElasti
 }
 export interface DescribeElasticsearchDomainsCommandOutput extends DescribeElasticsearchDomainsResponse, __MetadataBearer {
 }
-/**
- * <p>Returns domain configuration information about the specified Elasticsearch domains, including the domain ID, domain endpoint, and domain ARN.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, DescribeElasticsearchDomainsCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, DescribeElasticsearchDomainsCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new DescribeElasticsearchDomainsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeElasticsearchDomainsCommandInput} for command's `input` shape.
- * @see {@link DescribeElasticsearchDomainsCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeElasticsearchDomainsCommand extends $Command<DescribeElasticsearchDomainsCommandInput, DescribeElasticsearchDomainsCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: DescribeElasticsearchDomainsCommandInput;
     constructor(input: DescribeElasticsearchDomainsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeElasticsearchDomainsCommandInput, DescribeElasticsearchDomainsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,36 +6,11 @@ export interface DescribeElasticsearchInstanceTypeLimitsCommandInput extends Des
 }
 export interface DescribeElasticsearchInstanceTypeLimitsCommandOutput extends DescribeElasticsearchInstanceTypeLimitsResponse, __MetadataBearer {
 }
-/**
- * <p>
- *     Describe Elasticsearch Limits for a given InstanceType and ElasticsearchVersion.
- *     When modifying existing Domain, specify the
- *     <code>
- *       <a>DomainName</a>
- *     </code>
- *     to know what Limits are supported for modifying.
- *   </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, DescribeElasticsearchInstanceTypeLimitsCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, DescribeElasticsearchInstanceTypeLimitsCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new DescribeElasticsearchInstanceTypeLimitsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeElasticsearchInstanceTypeLimitsCommandInput} for command's `input` shape.
- * @see {@link DescribeElasticsearchInstanceTypeLimitsCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeElasticsearchInstanceTypeLimitsCommand extends $Command<DescribeElasticsearchInstanceTypeLimitsCommandInput, DescribeElasticsearchInstanceTypeLimitsCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: DescribeElasticsearchInstanceTypeLimitsCommandInput;
     constructor(input: DescribeElasticsearchInstanceTypeLimitsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeElasticsearchInstanceTypeLimitsCommandInput, DescribeElasticsearchInstanceTypeLimitsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeInboundCrossClusterSearchConnectionsCommandInput extend
 }
 export interface DescribeInboundCrossClusterSearchConnectionsCommandOutput extends DescribeInboundCrossClusterSearchConnectionsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists all the inbound cross-cluster search connections for a destination domain.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, DescribeInboundCrossClusterSearchConnectionsCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, DescribeInboundCrossClusterSearchConnectionsCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new DescribeInboundCrossClusterSearchConnectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeInboundCrossClusterSearchConnectionsCommandInput} for command's `input` shape.
- * @see {@link DescribeInboundCrossClusterSearchConnectionsCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeInboundCrossClusterSearchConnectionsCommand extends $Command<DescribeInboundCrossClusterSearchConnectionsCommandInput, DescribeInboundCrossClusterSearchConnectionsCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: DescribeInboundCrossClusterSearchConnectionsCommandInput;
     constructor(input: DescribeInboundCrossClusterSearchConnectionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeInboundCrossClusterSearchConnectionsCommandInput, DescribeInboundCrossClusterSearchConnectionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeOutboundCrossClusterSearchConnectionsCommandInput exten
 }
 export interface DescribeOutboundCrossClusterSearchConnectionsCommandOutput extends DescribeOutboundCrossClusterSearchConnectionsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists all the outbound cross-cluster search connections for a source domain.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { ElasticsearchServiceClient, DescribeOutboundCrossClusterSearchConnectionsCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
- * // const { ElasticsearchServiceClient, DescribeOutboundCrossClusterSearchConnectionsCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
- * const client = new ElasticsearchServiceClient(config);
- * const command = new DescribeOutboundCrossClusterSearchConnectionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeOutboundCrossClusterSearchConnectionsCommandInput} for command's `input` shape.
- * @see {@link DescribeOutboundCrossClusterSearchConnectionsCommandOutput} for command's `response` shape.
- * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeOutboundCrossClusterSearchConnectionsCommand extends $Command<DescribeOutboundCrossClusterSearchConnectionsCommandInput, DescribeOutboundCrossClusterSearchConnectionsCommandOutput, ElasticsearchServiceClientResolvedConfig> {
     readonly input: DescribeOutboundCrossClusterSearchConnectionsCommandInput;
     constructor(input: DescribeOutboundCrossClusterSearchConnectionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeOutboundCrossClusterSearchConnectionsCommandInput, DescribeOutboundCrossClusterSearchConnectionsCommandOutput>;
     private serialize;
     private deserialize;