@aws-sdk/client-elasticsearch-service 3.31.0 → 3.35.0

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { CancelElasticsearchServiceSoftwareUpdateRequest, CancelElasticsearchServiceSoftwareUpdateResponse } from "../models/models_0";
+export interface CancelElasticsearchServiceSoftwareUpdateCommandInput extends CancelElasticsearchServiceSoftwareUpdateRequest {
+}
+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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { CreateElasticsearchDomainRequest, CreateElasticsearchDomainResponse } from "../models/models_0";
+export interface CreateElasticsearchDomainCommandInput extends CreateElasticsearchDomainRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { CreateOutboundCrossClusterSearchConnectionRequest, CreateOutboundCrossClusterSearchConnectionResponse } from "../models/models_0";
+export interface CreateOutboundCrossClusterSearchConnectionCommandInput extends CreateOutboundCrossClusterSearchConnectionRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { CreatePackageRequest, CreatePackageResponse } from "../models/models_0";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DeleteElasticsearchDomainRequest, DeleteElasticsearchDomainResponse } from "../models/models_0";
+export interface DeleteElasticsearchDomainCommandInput extends DeleteElasticsearchDomainRequest {
+}
+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

@@ -0,0 +1,34 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DeleteInboundCrossClusterSearchConnectionRequest, DeleteInboundCrossClusterSearchConnectionResponse } from "../models/models_0";
+export interface DeleteInboundCrossClusterSearchConnectionCommandInput extends DeleteInboundCrossClusterSearchConnectionRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DeleteOutboundCrossClusterSearchConnectionRequest, DeleteOutboundCrossClusterSearchConnectionResponse } from "../models/models_0";
+export interface DeleteOutboundCrossClusterSearchConnectionCommandInput extends DeleteOutboundCrossClusterSearchConnectionRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DeletePackageRequest, DeletePackageResponse } from "../models/models_0";
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DescribeDomainAutoTunesRequest, DescribeDomainAutoTunesResponse } from "../models/models_0";
+export interface DescribeDomainAutoTunesCommandInput extends DescribeDomainAutoTunesRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DescribeElasticsearchDomainRequest, DescribeElasticsearchDomainResponse } from "../models/models_0";
+export interface DescribeElasticsearchDomainCommandInput extends DescribeElasticsearchDomainRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DescribeElasticsearchDomainConfigRequest, DescribeElasticsearchDomainConfigResponse } from "../models/models_0";
+export interface DescribeElasticsearchDomainConfigCommandInput extends DescribeElasticsearchDomainConfigRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DescribeElasticsearchDomainsRequest, DescribeElasticsearchDomainsResponse } from "../models/models_0";
+export interface DescribeElasticsearchDomainsCommandInput extends DescribeElasticsearchDomainsRequest {
+}
+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

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DescribeElasticsearchInstanceTypeLimitsRequest, DescribeElasticsearchInstanceTypeLimitsResponse } from "../models/models_0";
+export interface DescribeElasticsearchInstanceTypeLimitsCommandInput extends DescribeElasticsearchInstanceTypeLimitsRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DescribeInboundCrossClusterSearchConnectionsRequest, DescribeInboundCrossClusterSearchConnectionsResponse } from "../models/models_0";
+export interface DescribeInboundCrossClusterSearchConnectionsCommandInput extends DescribeInboundCrossClusterSearchConnectionsRequest {
+}
+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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DescribeOutboundCrossClusterSearchConnectionsRequest, DescribeOutboundCrossClusterSearchConnectionsResponse } from "../models/models_0";
+export interface DescribeOutboundCrossClusterSearchConnectionsCommandInput extends DescribeOutboundCrossClusterSearchConnectionsRequest {
+}
+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;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ElasticsearchServiceClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../ElasticsearchServiceClient";
+import { DescribePackagesRequest, DescribePackagesResponse } from "../models/models_0";
+export interface DescribePackagesCommandInput extends DescribePackagesRequest {
+}
+export interface DescribePackagesCommandOutput extends DescribePackagesResponse, __MetadataBearer {
+}
+/**
+ * <p>Describes all packages available to Amazon ES. Includes options for filtering, limiting the number of results, and pagination.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { ElasticsearchServiceClient, DescribePackagesCommand } from "@aws-sdk/client-elasticsearch-service"; // ES Modules import
+ * // const { ElasticsearchServiceClient, DescribePackagesCommand } = require("@aws-sdk/client-elasticsearch-service"); // CommonJS import
+ * const client = new ElasticsearchServiceClient(config);
+ * const command = new DescribePackagesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DescribePackagesCommandInput} for command's `input` shape.
+ * @see {@link DescribePackagesCommandOutput} for command's `response` shape.
+ * @see {@link ElasticsearchServiceClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class DescribePackagesCommand extends $Command<DescribePackagesCommandInput, DescribePackagesCommandOutput, ElasticsearchServiceClientResolvedConfig> {
+    readonly input: DescribePackagesCommandInput;
+    constructor(input: DescribePackagesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: ElasticsearchServiceClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribePackagesCommandInput, DescribePackagesCommandOutput>;
+    private serialize;
+    private deserialize;
+}