@aws-sdk/client-opensearchserverless 3.220.0

package/dist-es/commands/BatchGetVpcEndpointCommand.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 { BatchGetVpcEndpointRequestFilterSensitiveLog, BatchGetVpcEndpointResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0BatchGetVpcEndpointCommand, serializeAws_json1_0BatchGetVpcEndpointCommand, } from "../protocols/Aws_json1_0";
+export class BatchGetVpcEndpointCommand 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, BatchGetVpcEndpointCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "BatchGetVpcEndpointCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: BatchGetVpcEndpointRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: BatchGetVpcEndpointResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0BatchGetVpcEndpointCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0BatchGetVpcEndpointCommand(output, context);
+    }
+}

package/dist-es/commands/CreateAccessPolicyCommand.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 { CreateAccessPolicyRequestFilterSensitiveLog, CreateAccessPolicyResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0CreateAccessPolicyCommand, serializeAws_json1_0CreateAccessPolicyCommand, } from "../protocols/Aws_json1_0";
+export class CreateAccessPolicyCommand 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, CreateAccessPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "CreateAccessPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateAccessPolicyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateAccessPolicyResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0CreateAccessPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0CreateAccessPolicyCommand(output, context);
+    }
+}

package/dist-es/commands/CreateCollectionCommand.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 { CreateCollectionRequestFilterSensitiveLog, CreateCollectionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0CreateCollectionCommand, serializeAws_json1_0CreateCollectionCommand, } from "../protocols/Aws_json1_0";
+export class CreateCollectionCommand 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, CreateCollectionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "CreateCollectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateCollectionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateCollectionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0CreateCollectionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0CreateCollectionCommand(output, context);
+    }
+}

package/dist-es/commands/CreateSecurityConfigCommand.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 { CreateSecurityConfigRequestFilterSensitiveLog, CreateSecurityConfigResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0CreateSecurityConfigCommand, serializeAws_json1_0CreateSecurityConfigCommand, } from "../protocols/Aws_json1_0";
+export class CreateSecurityConfigCommand 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, CreateSecurityConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "CreateSecurityConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateSecurityConfigRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateSecurityConfigResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0CreateSecurityConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0CreateSecurityConfigCommand(output, context);
+    }
+}

package/dist-es/commands/CreateSecurityPolicyCommand.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 { CreateSecurityPolicyRequestFilterSensitiveLog, CreateSecurityPolicyResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0CreateSecurityPolicyCommand, serializeAws_json1_0CreateSecurityPolicyCommand, } from "../protocols/Aws_json1_0";
+export class CreateSecurityPolicyCommand 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, CreateSecurityPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "CreateSecurityPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateSecurityPolicyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateSecurityPolicyResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0CreateSecurityPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0CreateSecurityPolicyCommand(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_json1_0CreateVpcEndpointCommand, serializeAws_json1_0CreateVpcEndpointCommand, } from "../protocols/Aws_json1_0";
+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 = "OpenSearchServerlessClient";
+        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_json1_0CreateVpcEndpointCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0CreateVpcEndpointCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteAccessPolicyCommand.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 { DeleteAccessPolicyRequestFilterSensitiveLog, DeleteAccessPolicyResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0DeleteAccessPolicyCommand, serializeAws_json1_0DeleteAccessPolicyCommand, } from "../protocols/Aws_json1_0";
+export class DeleteAccessPolicyCommand 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, DeleteAccessPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "DeleteAccessPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteAccessPolicyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteAccessPolicyResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0DeleteAccessPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0DeleteAccessPolicyCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteCollectionCommand.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 { DeleteCollectionRequestFilterSensitiveLog, DeleteCollectionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0DeleteCollectionCommand, serializeAws_json1_0DeleteCollectionCommand, } from "../protocols/Aws_json1_0";
+export class DeleteCollectionCommand 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, DeleteCollectionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "DeleteCollectionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteCollectionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteCollectionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0DeleteCollectionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0DeleteCollectionCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteSecurityConfigCommand.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 { DeleteSecurityConfigRequestFilterSensitiveLog, DeleteSecurityConfigResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0DeleteSecurityConfigCommand, serializeAws_json1_0DeleteSecurityConfigCommand, } from "../protocols/Aws_json1_0";
+export class DeleteSecurityConfigCommand 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, DeleteSecurityConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "DeleteSecurityConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteSecurityConfigRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteSecurityConfigResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0DeleteSecurityConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0DeleteSecurityConfigCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteSecurityPolicyCommand.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 { DeleteSecurityPolicyRequestFilterSensitiveLog, DeleteSecurityPolicyResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0DeleteSecurityPolicyCommand, serializeAws_json1_0DeleteSecurityPolicyCommand, } from "../protocols/Aws_json1_0";
+export class DeleteSecurityPolicyCommand 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, DeleteSecurityPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "DeleteSecurityPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteSecurityPolicyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteSecurityPolicyResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0DeleteSecurityPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0DeleteSecurityPolicyCommand(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_json1_0DeleteVpcEndpointCommand, serializeAws_json1_0DeleteVpcEndpointCommand, } from "../protocols/Aws_json1_0";
+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 = "OpenSearchServerlessClient";
+        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_json1_0DeleteVpcEndpointCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0DeleteVpcEndpointCommand(output, context);
+    }
+}

package/dist-es/commands/GetAccessPolicyCommand.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 { GetAccessPolicyRequestFilterSensitiveLog, GetAccessPolicyResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetAccessPolicyCommand, serializeAws_json1_0GetAccessPolicyCommand, } from "../protocols/Aws_json1_0";
+export class GetAccessPolicyCommand 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, GetAccessPolicyCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "GetAccessPolicyCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetAccessPolicyRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetAccessPolicyResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetAccessPolicyCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetAccessPolicyCommand(output, context);
+    }
+}

package/dist-es/commands/GetAccountSettingsCommand.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 { GetAccountSettingsRequestFilterSensitiveLog, GetAccountSettingsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetAccountSettingsCommand, serializeAws_json1_0GetAccountSettingsCommand, } from "../protocols/Aws_json1_0";
+export class GetAccountSettingsCommand 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, GetAccountSettingsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "GetAccountSettingsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetAccountSettingsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetAccountSettingsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetAccountSettingsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetAccountSettingsCommand(output, context);
+    }
+}

package/dist-es/commands/GetPoliciesStatsCommand.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 { GetPoliciesStatsRequestFilterSensitiveLog, GetPoliciesStatsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetPoliciesStatsCommand, serializeAws_json1_0GetPoliciesStatsCommand, } from "../protocols/Aws_json1_0";
+export class GetPoliciesStatsCommand 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, GetPoliciesStatsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "GetPoliciesStatsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetPoliciesStatsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetPoliciesStatsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetPoliciesStatsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetPoliciesStatsCommand(output, context);
+    }
+}

package/dist-es/commands/GetSecurityConfigCommand.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 { GetSecurityConfigRequestFilterSensitiveLog, GetSecurityConfigResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_json1_0GetSecurityConfigCommand, serializeAws_json1_0GetSecurityConfigCommand, } from "../protocols/Aws_json1_0";
+export class GetSecurityConfigCommand 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, GetSecurityConfigCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "OpenSearchServerlessClient";
+        const commandName = "GetSecurityConfigCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetSecurityConfigRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetSecurityConfigResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_json1_0GetSecurityConfigCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_json1_0GetSecurityConfigCommand(output, context);
+    }
+}