@aws-sdk/client-tnb 3.276.0

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

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

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

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

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

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

package/dist-es/commands/ListSolNetworkPackagesCommand.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 { ListSolNetworkPackagesInputFilterSensitiveLog, ListSolNetworkPackagesOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListSolNetworkPackagesCommand, serializeAws_restJson1ListSolNetworkPackagesCommand, } from "../protocols/Aws_restJson1";
+export class ListSolNetworkPackagesCommand 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, ListSolNetworkPackagesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "TnbClient";
+        const commandName = "ListSolNetworkPackagesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListSolNetworkPackagesInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListSolNetworkPackagesOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListSolNetworkPackagesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListSolNetworkPackagesCommand(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 { ListTagsForResourceInputFilterSensitiveLog, ListTagsForResourceOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListTagsForResourceCommand, serializeAws_restJson1ListTagsForResourceCommand, } from "../protocols/Aws_restJson1";
+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 = "TnbClient";
+        const commandName = "ListTagsForResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListTagsForResourceInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ListTagsForResourceOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListTagsForResourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListTagsForResourceCommand(output, context);
+    }
+}

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

package/dist-es/commands/PutSolNetworkPackageContentCommand.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 { PutSolNetworkPackageContentInputFilterSensitiveLog, PutSolNetworkPackageContentOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1PutSolNetworkPackageContentCommand, serializeAws_restJson1PutSolNetworkPackageContentCommand, } from "../protocols/Aws_restJson1";
+export class PutSolNetworkPackageContentCommand 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, PutSolNetworkPackageContentCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "TnbClient";
+        const commandName = "PutSolNetworkPackageContentCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: PutSolNetworkPackageContentInputFilterSensitiveLog,
+            outputFilterSensitiveLog: PutSolNetworkPackageContentOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1PutSolNetworkPackageContentCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1PutSolNetworkPackageContentCommand(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 { TagResourceInputFilterSensitiveLog, TagResourceOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1TagResourceCommand, serializeAws_restJson1TagResourceCommand, } from "../protocols/Aws_restJson1";
+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 = "TnbClient";
+        const commandName = "TagResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: TagResourceInputFilterSensitiveLog,
+            outputFilterSensitiveLog: TagResourceOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1TagResourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1TagResourceCommand(output, context);
+    }
+}

package/dist-es/commands/TerminateSolNetworkInstanceCommand.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 { TerminateSolNetworkInstanceInputFilterSensitiveLog, TerminateSolNetworkInstanceOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1TerminateSolNetworkInstanceCommand, serializeAws_restJson1TerminateSolNetworkInstanceCommand, } from "../protocols/Aws_restJson1";
+export class TerminateSolNetworkInstanceCommand 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, TerminateSolNetworkInstanceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "TnbClient";
+        const commandName = "TerminateSolNetworkInstanceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: TerminateSolNetworkInstanceInputFilterSensitiveLog,
+            outputFilterSensitiveLog: TerminateSolNetworkInstanceOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1TerminateSolNetworkInstanceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1TerminateSolNetworkInstanceCommand(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 { UntagResourceInputFilterSensitiveLog, UntagResourceOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UntagResourceCommand, serializeAws_restJson1UntagResourceCommand, } from "../protocols/Aws_restJson1";
+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 = "TnbClient";
+        const commandName = "UntagResourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UntagResourceInputFilterSensitiveLog,
+            outputFilterSensitiveLog: UntagResourceOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UntagResourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UntagResourceCommand(output, context);
+    }
+}

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

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