@aws-sdk/client-elasticsearch-service 3.202.0 → 3.208.0

package/dist-cjs/ElasticsearchService.js

@@ -4,15 +4,18 @@ exports.ElasticsearchService = void 0;
 const AcceptInboundCrossClusterSearchConnectionCommand_1 = require("./commands/AcceptInboundCrossClusterSearchConnectionCommand");
 const AddTagsCommand_1 = require("./commands/AddTagsCommand");
 const AssociatePackageCommand_1 = require("./commands/AssociatePackageCommand");
+const AuthorizeVpcEndpointAccessCommand_1 = require("./commands/AuthorizeVpcEndpointAccessCommand");
 const CancelElasticsearchServiceSoftwareUpdateCommand_1 = require("./commands/CancelElasticsearchServiceSoftwareUpdateCommand");
 const CreateElasticsearchDomainCommand_1 = require("./commands/CreateElasticsearchDomainCommand");
 const CreateOutboundCrossClusterSearchConnectionCommand_1 = require("./commands/CreateOutboundCrossClusterSearchConnectionCommand");
 const CreatePackageCommand_1 = require("./commands/CreatePackageCommand");
+const CreateVpcEndpointCommand_1 = require("./commands/CreateVpcEndpointCommand");
 const DeleteElasticsearchDomainCommand_1 = require("./commands/DeleteElasticsearchDomainCommand");
 const DeleteElasticsearchServiceRoleCommand_1 = require("./commands/DeleteElasticsearchServiceRoleCommand");
 const DeleteInboundCrossClusterSearchConnectionCommand_1 = require("./commands/DeleteInboundCrossClusterSearchConnectionCommand");
 const DeleteOutboundCrossClusterSearchConnectionCommand_1 = require("./commands/DeleteOutboundCrossClusterSearchConnectionCommand");
 const DeletePackageCommand_1 = require("./commands/DeletePackageCommand");
+const DeleteVpcEndpointCommand_1 = require("./commands/DeleteVpcEndpointCommand");
 const DescribeDomainAutoTunesCommand_1 = require("./commands/DescribeDomainAutoTunesCommand");
 const DescribeDomainChangeProgressCommand_1 = require("./commands/DescribeDomainChangeProgressCommand");
 const DescribeElasticsearchDomainCommand_1 = require("./commands/DescribeElasticsearchDomainCommand");
@@ -24,6 +27,7 @@ const DescribeOutboundCrossClusterSearchConnectionsCommand_1 = require("./comman
 const DescribePackagesCommand_1 = require("./commands/DescribePackagesCommand");
 const DescribeReservedElasticsearchInstanceOfferingsCommand_1 = require("./commands/DescribeReservedElasticsearchInstanceOfferingsCommand");
 const DescribeReservedElasticsearchInstancesCommand_1 = require("./commands/DescribeReservedElasticsearchInstancesCommand");
+const DescribeVpcEndpointsCommand_1 = require("./commands/DescribeVpcEndpointsCommand");
 const DissociatePackageCommand_1 = require("./commands/DissociatePackageCommand");
 const GetCompatibleElasticsearchVersionsCommand_1 = require("./commands/GetCompatibleElasticsearchVersionsCommand");
 const GetPackageVersionHistoryCommand_1 = require("./commands/GetPackageVersionHistoryCommand");
@@ -35,12 +39,17 @@ const ListElasticsearchInstanceTypesCommand_1 = require("./commands/ListElastics
 const ListElasticsearchVersionsCommand_1 = require("./commands/ListElasticsearchVersionsCommand");
 const ListPackagesForDomainCommand_1 = require("./commands/ListPackagesForDomainCommand");
 const ListTagsCommand_1 = require("./commands/ListTagsCommand");
+const ListVpcEndpointAccessCommand_1 = require("./commands/ListVpcEndpointAccessCommand");
+const ListVpcEndpointsCommand_1 = require("./commands/ListVpcEndpointsCommand");
+const ListVpcEndpointsForDomainCommand_1 = require("./commands/ListVpcEndpointsForDomainCommand");
 const PurchaseReservedElasticsearchInstanceOfferingCommand_1 = require("./commands/PurchaseReservedElasticsearchInstanceOfferingCommand");
 const RejectInboundCrossClusterSearchConnectionCommand_1 = require("./commands/RejectInboundCrossClusterSearchConnectionCommand");
 const RemoveTagsCommand_1 = require("./commands/RemoveTagsCommand");
+const RevokeVpcEndpointAccessCommand_1 = require("./commands/RevokeVpcEndpointAccessCommand");
 const StartElasticsearchServiceSoftwareUpdateCommand_1 = require("./commands/StartElasticsearchServiceSoftwareUpdateCommand");
 const UpdateElasticsearchDomainConfigCommand_1 = require("./commands/UpdateElasticsearchDomainConfigCommand");
 const UpdatePackageCommand_1 = require("./commands/UpdatePackageCommand");
+const UpdateVpcEndpointCommand_1 = require("./commands/UpdateVpcEndpointCommand");
 const UpgradeElasticsearchDomainCommand_1 = require("./commands/UpgradeElasticsearchDomainCommand");
 const ElasticsearchServiceClient_1 = require("./ElasticsearchServiceClient");
 class ElasticsearchService extends ElasticsearchServiceClient_1.ElasticsearchServiceClient {
@@ -86,6 +95,20 @@ class ElasticsearchService extends ElasticsearchServiceClient_1.ElasticsearchSer
             return this.send(command, optionsOrCb);
         }
     }
+    authorizeVpcEndpointAccess(args, optionsOrCb, cb) {
+        const command = new AuthorizeVpcEndpointAccessCommand_1.AuthorizeVpcEndpointAccessCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     cancelElasticsearchServiceSoftwareUpdate(args, optionsOrCb, cb) {
         const command = new CancelElasticsearchServiceSoftwareUpdateCommand_1.CancelElasticsearchServiceSoftwareUpdateCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -142,6 +165,20 @@ class ElasticsearchService extends ElasticsearchServiceClient_1.ElasticsearchSer
             return this.send(command, optionsOrCb);
         }
     }
+    createVpcEndpoint(args, optionsOrCb, cb) {
+        const command = new CreateVpcEndpointCommand_1.CreateVpcEndpointCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     deleteElasticsearchDomain(args, optionsOrCb, cb) {
         const command = new DeleteElasticsearchDomainCommand_1.DeleteElasticsearchDomainCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -212,6 +249,20 @@ class ElasticsearchService extends ElasticsearchServiceClient_1.ElasticsearchSer
             return this.send(command, optionsOrCb);
         }
     }
+    deleteVpcEndpoint(args, optionsOrCb, cb) {
+        const command = new DeleteVpcEndpointCommand_1.DeleteVpcEndpointCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     describeDomainAutoTunes(args, optionsOrCb, cb) {
         const command = new DescribeDomainAutoTunesCommand_1.DescribeDomainAutoTunesCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -366,6 +417,20 @@ class ElasticsearchService extends ElasticsearchServiceClient_1.ElasticsearchSer
             return this.send(command, optionsOrCb);
         }
     }
+    describeVpcEndpoints(args, optionsOrCb, cb) {
+        const command = new DescribeVpcEndpointsCommand_1.DescribeVpcEndpointsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     dissociatePackage(args, optionsOrCb, cb) {
         const command = new DissociatePackageCommand_1.DissociatePackageCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -520,6 +585,48 @@ class ElasticsearchService extends ElasticsearchServiceClient_1.ElasticsearchSer
             return this.send(command, optionsOrCb);
         }
     }
+    listVpcEndpointAccess(args, optionsOrCb, cb) {
+        const command = new ListVpcEndpointAccessCommand_1.ListVpcEndpointAccessCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listVpcEndpoints(args, optionsOrCb, cb) {
+        const command = new ListVpcEndpointsCommand_1.ListVpcEndpointsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
+    listVpcEndpointsForDomain(args, optionsOrCb, cb) {
+        const command = new ListVpcEndpointsForDomainCommand_1.ListVpcEndpointsForDomainCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     purchaseReservedElasticsearchInstanceOffering(args, optionsOrCb, cb) {
         const command = new PurchaseReservedElasticsearchInstanceOfferingCommand_1.PurchaseReservedElasticsearchInstanceOfferingCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -562,6 +669,20 @@ class ElasticsearchService extends ElasticsearchServiceClient_1.ElasticsearchSer
             return this.send(command, optionsOrCb);
         }
     }
+    revokeVpcEndpointAccess(args, optionsOrCb, cb) {
+        const command = new RevokeVpcEndpointAccessCommand_1.RevokeVpcEndpointAccessCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     startElasticsearchServiceSoftwareUpdate(args, optionsOrCb, cb) {
         const command = new StartElasticsearchServiceSoftwareUpdateCommand_1.StartElasticsearchServiceSoftwareUpdateCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -604,6 +725,20 @@ class ElasticsearchService extends ElasticsearchServiceClient_1.ElasticsearchSer
             return this.send(command, optionsOrCb);
         }
     }
+    updateVpcEndpoint(args, optionsOrCb, cb) {
+        const command = new UpdateVpcEndpointCommand_1.UpdateVpcEndpointCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     upgradeElasticsearchDomain(args, optionsOrCb, cb) {
         const command = new UpgradeElasticsearchDomainCommand_1.UpgradeElasticsearchDomainCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-cjs/commands/AuthorizeVpcEndpointAccessCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizeVpcEndpointAccessCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class AuthorizeVpcEndpointAccessCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, AuthorizeVpcEndpointAccessCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElasticsearchServiceClient";
+        const commandName = "AuthorizeVpcEndpointAccessCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.AuthorizeVpcEndpointAccessRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.AuthorizeVpcEndpointAccessResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1AuthorizeVpcEndpointAccessCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1AuthorizeVpcEndpointAccessCommand)(output, context);
+    }
+}
+exports.AuthorizeVpcEndpointAccessCommand = AuthorizeVpcEndpointAccessCommand;

package/dist-cjs/commands/CreateVpcEndpointCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateVpcEndpointCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class CreateVpcEndpointCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateVpcEndpointCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElasticsearchServiceClient";
+        const commandName = "CreateVpcEndpointCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.CreateVpcEndpointRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.CreateVpcEndpointResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1CreateVpcEndpointCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1CreateVpcEndpointCommand)(output, context);
+    }
+}
+exports.CreateVpcEndpointCommand = CreateVpcEndpointCommand;

package/dist-cjs/commands/DeleteVpcEndpointCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteVpcEndpointCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class DeleteVpcEndpointCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteVpcEndpointCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElasticsearchServiceClient";
+        const commandName = "DeleteVpcEndpointCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.DeleteVpcEndpointRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.DeleteVpcEndpointResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1DeleteVpcEndpointCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1DeleteVpcEndpointCommand)(output, context);
+    }
+}
+exports.DeleteVpcEndpointCommand = DeleteVpcEndpointCommand;

package/dist-cjs/commands/DescribeVpcEndpointsCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescribeVpcEndpointsCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class DescribeVpcEndpointsCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DescribeVpcEndpointsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElasticsearchServiceClient";
+        const commandName = "DescribeVpcEndpointsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.DescribeVpcEndpointsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.DescribeVpcEndpointsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1DescribeVpcEndpointsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1DescribeVpcEndpointsCommand)(output, context);
+    }
+}
+exports.DescribeVpcEndpointsCommand = DescribeVpcEndpointsCommand;

package/dist-cjs/commands/ListVpcEndpointAccessCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListVpcEndpointAccessCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class ListVpcEndpointAccessCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListVpcEndpointAccessCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElasticsearchServiceClient";
+        const commandName = "ListVpcEndpointAccessCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.ListVpcEndpointAccessRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.ListVpcEndpointAccessResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1ListVpcEndpointAccessCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1ListVpcEndpointAccessCommand)(output, context);
+    }
+}
+exports.ListVpcEndpointAccessCommand = ListVpcEndpointAccessCommand;

package/dist-cjs/commands/ListVpcEndpointsCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListVpcEndpointsCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class ListVpcEndpointsCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListVpcEndpointsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElasticsearchServiceClient";
+        const commandName = "ListVpcEndpointsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.ListVpcEndpointsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.ListVpcEndpointsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1ListVpcEndpointsCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1ListVpcEndpointsCommand)(output, context);
+    }
+}
+exports.ListVpcEndpointsCommand = ListVpcEndpointsCommand;

package/dist-cjs/commands/ListVpcEndpointsForDomainCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListVpcEndpointsForDomainCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class ListVpcEndpointsForDomainCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, ListVpcEndpointsForDomainCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElasticsearchServiceClient";
+        const commandName = "ListVpcEndpointsForDomainCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.ListVpcEndpointsForDomainRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.ListVpcEndpointsForDomainResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1ListVpcEndpointsForDomainCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1ListVpcEndpointsForDomainCommand)(output, context);
+    }
+}
+exports.ListVpcEndpointsForDomainCommand = ListVpcEndpointsForDomainCommand;

package/dist-cjs/commands/RevokeVpcEndpointAccessCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevokeVpcEndpointAccessCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class RevokeVpcEndpointAccessCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, RevokeVpcEndpointAccessCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElasticsearchServiceClient";
+        const commandName = "RevokeVpcEndpointAccessCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.RevokeVpcEndpointAccessRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.RevokeVpcEndpointAccessResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1RevokeVpcEndpointAccessCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1RevokeVpcEndpointAccessCommand)(output, context);
+    }
+}
+exports.RevokeVpcEndpointAccessCommand = RevokeVpcEndpointAccessCommand;

package/dist-cjs/commands/UpdateVpcEndpointCommand.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateVpcEndpointCommand = void 0;
+const middleware_endpoint_1 = require("@aws-sdk/middleware-endpoint");
+const middleware_serde_1 = require("@aws-sdk/middleware-serde");
+const smithy_client_1 = require("@aws-sdk/smithy-client");
+const models_0_1 = require("../models/models_0");
+const Aws_restJson1_1 = require("../protocols/Aws_restJson1");
+class UpdateVpcEndpointCommand extends smithy_client_1.Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, UpdateVpcEndpointCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ElasticsearchServiceClient";
+        const commandName = "UpdateVpcEndpointCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: models_0_1.UpdateVpcEndpointRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: models_0_1.UpdateVpcEndpointResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return (0, Aws_restJson1_1.serializeAws_restJson1UpdateVpcEndpointCommand)(input, context);
+    }
+    deserialize(output, context) {
+        return (0, Aws_restJson1_1.deserializeAws_restJson1UpdateVpcEndpointCommand)(output, context);
+    }
+}
+exports.UpdateVpcEndpointCommand = UpdateVpcEndpointCommand;