@aws-sdk/client-opensearchserverless 3.220.0

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

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

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

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

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

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

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

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

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

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

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

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

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