@aws-sdk/client-tnb 3.276.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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