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

package/dist-es/ElasticsearchService.js

@@ -1,15 +1,18 @@
 import { AcceptInboundCrossClusterSearchConnectionCommand, } from "./commands/AcceptInboundCrossClusterSearchConnectionCommand";
 import { AddTagsCommand } from "./commands/AddTagsCommand";
 import { AssociatePackageCommand, } from "./commands/AssociatePackageCommand";
+import { AuthorizeVpcEndpointAccessCommand, } from "./commands/AuthorizeVpcEndpointAccessCommand";
 import { CancelElasticsearchServiceSoftwareUpdateCommand, } from "./commands/CancelElasticsearchServiceSoftwareUpdateCommand";
 import { CreateElasticsearchDomainCommand, } from "./commands/CreateElasticsearchDomainCommand";
 import { CreateOutboundCrossClusterSearchConnectionCommand, } from "./commands/CreateOutboundCrossClusterSearchConnectionCommand";
 import { CreatePackageCommand, } from "./commands/CreatePackageCommand";
+import { CreateVpcEndpointCommand, } from "./commands/CreateVpcEndpointCommand";
 import { DeleteElasticsearchDomainCommand, } from "./commands/DeleteElasticsearchDomainCommand";
 import { DeleteElasticsearchServiceRoleCommand, } from "./commands/DeleteElasticsearchServiceRoleCommand";
 import { DeleteInboundCrossClusterSearchConnectionCommand, } from "./commands/DeleteInboundCrossClusterSearchConnectionCommand";
 import { DeleteOutboundCrossClusterSearchConnectionCommand, } from "./commands/DeleteOutboundCrossClusterSearchConnectionCommand";
 import { DeletePackageCommand, } from "./commands/DeletePackageCommand";
+import { DeleteVpcEndpointCommand, } from "./commands/DeleteVpcEndpointCommand";
 import { DescribeDomainAutoTunesCommand, } from "./commands/DescribeDomainAutoTunesCommand";
 import { DescribeDomainChangeProgressCommand, } from "./commands/DescribeDomainChangeProgressCommand";
 import { DescribeElasticsearchDomainCommand, } from "./commands/DescribeElasticsearchDomainCommand";
@@ -21,6 +24,7 @@ import { DescribeOutboundCrossClusterSearchConnectionsCommand, } from "./command
 import { DescribePackagesCommand, } from "./commands/DescribePackagesCommand";
 import { DescribeReservedElasticsearchInstanceOfferingsCommand, } from "./commands/DescribeReservedElasticsearchInstanceOfferingsCommand";
 import { DescribeReservedElasticsearchInstancesCommand, } from "./commands/DescribeReservedElasticsearchInstancesCommand";
+import { DescribeVpcEndpointsCommand, } from "./commands/DescribeVpcEndpointsCommand";
 import { DissociatePackageCommand, } from "./commands/DissociatePackageCommand";
 import { GetCompatibleElasticsearchVersionsCommand, } from "./commands/GetCompatibleElasticsearchVersionsCommand";
 import { GetPackageVersionHistoryCommand, } from "./commands/GetPackageVersionHistoryCommand";
@@ -32,12 +36,17 @@ import { ListElasticsearchInstanceTypesCommand, } from "./commands/ListElasticse
 import { ListElasticsearchVersionsCommand, } from "./commands/ListElasticsearchVersionsCommand";
 import { ListPackagesForDomainCommand, } from "./commands/ListPackagesForDomainCommand";
 import { ListTagsCommand } from "./commands/ListTagsCommand";
+import { ListVpcEndpointAccessCommand, } from "./commands/ListVpcEndpointAccessCommand";
+import { ListVpcEndpointsCommand, } from "./commands/ListVpcEndpointsCommand";
+import { ListVpcEndpointsForDomainCommand, } from "./commands/ListVpcEndpointsForDomainCommand";
 import { PurchaseReservedElasticsearchInstanceOfferingCommand, } from "./commands/PurchaseReservedElasticsearchInstanceOfferingCommand";
 import { RejectInboundCrossClusterSearchConnectionCommand, } from "./commands/RejectInboundCrossClusterSearchConnectionCommand";
 import { RemoveTagsCommand } from "./commands/RemoveTagsCommand";
+import { RevokeVpcEndpointAccessCommand, } from "./commands/RevokeVpcEndpointAccessCommand";
 import { StartElasticsearchServiceSoftwareUpdateCommand, } from "./commands/StartElasticsearchServiceSoftwareUpdateCommand";
 import { UpdateElasticsearchDomainConfigCommand, } from "./commands/UpdateElasticsearchDomainConfigCommand";
 import { UpdatePackageCommand, } from "./commands/UpdatePackageCommand";
+import { UpdateVpcEndpointCommand, } from "./commands/UpdateVpcEndpointCommand";
 import { UpgradeElasticsearchDomainCommand, } from "./commands/UpgradeElasticsearchDomainCommand";
 import { ElasticsearchServiceClient } from "./ElasticsearchServiceClient";
 export class ElasticsearchService extends ElasticsearchServiceClient {
@@ -83,6 +92,20 @@ export class ElasticsearchService extends ElasticsearchServiceClient {
             return this.send(command, optionsOrCb);
         }
     }
+    authorizeVpcEndpointAccess(args, optionsOrCb, cb) {
+        const command = new 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(args);
         if (typeof optionsOrCb === "function") {
@@ -139,6 +162,20 @@ export class ElasticsearchService extends ElasticsearchServiceClient {
             return this.send(command, optionsOrCb);
         }
     }
+    createVpcEndpoint(args, optionsOrCb, cb) {
+        const command = new 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(args);
         if (typeof optionsOrCb === "function") {
@@ -209,6 +246,20 @@ export class ElasticsearchService extends ElasticsearchServiceClient {
             return this.send(command, optionsOrCb);
         }
     }
+    deleteVpcEndpoint(args, optionsOrCb, cb) {
+        const command = new 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(args);
         if (typeof optionsOrCb === "function") {
@@ -363,6 +414,20 @@ export class ElasticsearchService extends ElasticsearchServiceClient {
             return this.send(command, optionsOrCb);
         }
     }
+    describeVpcEndpoints(args, optionsOrCb, cb) {
+        const command = new 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(args);
         if (typeof optionsOrCb === "function") {
@@ -517,6 +582,48 @@ export class ElasticsearchService extends ElasticsearchServiceClient {
             return this.send(command, optionsOrCb);
         }
     }
+    listVpcEndpointAccess(args, optionsOrCb, cb) {
+        const command = new 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(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(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(args);
         if (typeof optionsOrCb === "function") {
@@ -559,6 +666,20 @@ export class ElasticsearchService extends ElasticsearchServiceClient {
             return this.send(command, optionsOrCb);
         }
     }
+    revokeVpcEndpointAccess(args, optionsOrCb, cb) {
+        const command = new 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(args);
         if (typeof optionsOrCb === "function") {
@@ -601,6 +722,20 @@ export class ElasticsearchService extends ElasticsearchServiceClient {
             return this.send(command, optionsOrCb);
         }
     }
+    updateVpcEndpoint(args, optionsOrCb, cb) {
+        const command = new 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(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/AuthorizeVpcEndpointAccessCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { AuthorizeVpcEndpointAccessRequestFilterSensitiveLog, AuthorizeVpcEndpointAccessResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1AuthorizeVpcEndpointAccessCommand, serializeAws_restJson1AuthorizeVpcEndpointAccessCommand, } from "../protocols/Aws_restJson1";
+export class AuthorizeVpcEndpointAccessCommand extends $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(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(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: AuthorizeVpcEndpointAccessRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: AuthorizeVpcEndpointAccessResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1AuthorizeVpcEndpointAccessCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1AuthorizeVpcEndpointAccessCommand(output, context);
+    }
+}

package/dist-es/commands/CreateVpcEndpointCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateVpcEndpointRequestFilterSensitiveLog, CreateVpcEndpointResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateVpcEndpointCommand, serializeAws_restJson1CreateVpcEndpointCommand, } from "../protocols/Aws_restJson1";
+export class CreateVpcEndpointCommand extends $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(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(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: CreateVpcEndpointRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateVpcEndpointResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateVpcEndpointCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateVpcEndpointCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteVpcEndpointCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteVpcEndpointRequestFilterSensitiveLog, DeleteVpcEndpointResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteVpcEndpointCommand, serializeAws_restJson1DeleteVpcEndpointCommand, } from "../protocols/Aws_restJson1";
+export class DeleteVpcEndpointCommand extends $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(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(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: DeleteVpcEndpointRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteVpcEndpointResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteVpcEndpointCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteVpcEndpointCommand(output, context);
+    }
+}

package/dist-es/commands/DescribeVpcEndpointsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DescribeVpcEndpointsRequestFilterSensitiveLog, DescribeVpcEndpointsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DescribeVpcEndpointsCommand, serializeAws_restJson1DescribeVpcEndpointsCommand, } from "../protocols/Aws_restJson1";
+export class DescribeVpcEndpointsCommand extends $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(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(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: DescribeVpcEndpointsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DescribeVpcEndpointsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DescribeVpcEndpointsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DescribeVpcEndpointsCommand(output, context);
+    }
+}

package/dist-es/commands/ListVpcEndpointAccessCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListVpcEndpointAccessRequestFilterSensitiveLog, ListVpcEndpointAccessResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListVpcEndpointAccessCommand, serializeAws_restJson1ListVpcEndpointAccessCommand, } from "../protocols/Aws_restJson1";
+export class ListVpcEndpointAccessCommand extends $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(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(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: ListVpcEndpointAccessRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListVpcEndpointAccessResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListVpcEndpointAccessCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListVpcEndpointAccessCommand(output, context);
+    }
+}

package/dist-es/commands/ListVpcEndpointsCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListVpcEndpointsRequestFilterSensitiveLog, ListVpcEndpointsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListVpcEndpointsCommand, serializeAws_restJson1ListVpcEndpointsCommand, } from "../protocols/Aws_restJson1";
+export class ListVpcEndpointsCommand extends $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(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(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: ListVpcEndpointsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListVpcEndpointsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListVpcEndpointsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListVpcEndpointsCommand(output, context);
+    }
+}

package/dist-es/commands/ListVpcEndpointsForDomainCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListVpcEndpointsForDomainRequestFilterSensitiveLog, ListVpcEndpointsForDomainResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListVpcEndpointsForDomainCommand, serializeAws_restJson1ListVpcEndpointsForDomainCommand, } from "../protocols/Aws_restJson1";
+export class ListVpcEndpointsForDomainCommand extends $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(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(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: ListVpcEndpointsForDomainRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListVpcEndpointsForDomainResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListVpcEndpointsForDomainCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListVpcEndpointsForDomainCommand(output, context);
+    }
+}

package/dist-es/commands/RevokeVpcEndpointAccessCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { RevokeVpcEndpointAccessRequestFilterSensitiveLog, RevokeVpcEndpointAccessResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1RevokeVpcEndpointAccessCommand, serializeAws_restJson1RevokeVpcEndpointAccessCommand, } from "../protocols/Aws_restJson1";
+export class RevokeVpcEndpointAccessCommand extends $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(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(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: RevokeVpcEndpointAccessRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: RevokeVpcEndpointAccessResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1RevokeVpcEndpointAccessCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1RevokeVpcEndpointAccessCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateVpcEndpointCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateVpcEndpointRequestFilterSensitiveLog, UpdateVpcEndpointResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UpdateVpcEndpointCommand, serializeAws_restJson1UpdateVpcEndpointCommand, } from "../protocols/Aws_restJson1";
+export class UpdateVpcEndpointCommand extends $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(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(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: UpdateVpcEndpointRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdateVpcEndpointResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UpdateVpcEndpointCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UpdateVpcEndpointCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -1,15 +1,18 @@
 export * from "./AcceptInboundCrossClusterSearchConnectionCommand";
 export * from "./AddTagsCommand";
 export * from "./AssociatePackageCommand";
+export * from "./AuthorizeVpcEndpointAccessCommand";
 export * from "./CancelElasticsearchServiceSoftwareUpdateCommand";
 export * from "./CreateElasticsearchDomainCommand";
 export * from "./CreateOutboundCrossClusterSearchConnectionCommand";
 export * from "./CreatePackageCommand";
+export * from "./CreateVpcEndpointCommand";
 export * from "./DeleteElasticsearchDomainCommand";
 export * from "./DeleteElasticsearchServiceRoleCommand";
 export * from "./DeleteInboundCrossClusterSearchConnectionCommand";
 export * from "./DeleteOutboundCrossClusterSearchConnectionCommand";
 export * from "./DeletePackageCommand";
+export * from "./DeleteVpcEndpointCommand";
 export * from "./DescribeDomainAutoTunesCommand";
 export * from "./DescribeDomainChangeProgressCommand";
 export * from "./DescribeElasticsearchDomainCommand";
@@ -21,6 +24,7 @@ export * from "./DescribeOutboundCrossClusterSearchConnectionsCommand";
 export * from "./DescribePackagesCommand";
 export * from "./DescribeReservedElasticsearchInstanceOfferingsCommand";
 export * from "./DescribeReservedElasticsearchInstancesCommand";
+export * from "./DescribeVpcEndpointsCommand";
 export * from "./DissociatePackageCommand";
 export * from "./GetCompatibleElasticsearchVersionsCommand";
 export * from "./GetPackageVersionHistoryCommand";
@@ -32,10 +36,15 @@ export * from "./ListElasticsearchInstanceTypesCommand";
 export * from "./ListElasticsearchVersionsCommand";
 export * from "./ListPackagesForDomainCommand";
 export * from "./ListTagsCommand";
+export * from "./ListVpcEndpointAccessCommand";
+export * from "./ListVpcEndpointsCommand";
+export * from "./ListVpcEndpointsForDomainCommand";
 export * from "./PurchaseReservedElasticsearchInstanceOfferingCommand";
 export * from "./RejectInboundCrossClusterSearchConnectionCommand";
 export * from "./RemoveTagsCommand";
+export * from "./RevokeVpcEndpointAccessCommand";
 export * from "./StartElasticsearchServiceSoftwareUpdateCommand";
 export * from "./UpdateElasticsearchDomainConfigCommand";
 export * from "./UpdatePackageCommand";
+export * from "./UpdateVpcEndpointCommand";
 export * from "./UpgradeElasticsearchDomainCommand";