@aws-sdk/client-tnb 3.276.0

package/dist-types/commands/GetSolNetworkPackageDescriptorCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GetSolNetworkPackageDescriptorInput, GetSolNetworkPackageDescriptorOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface GetSolNetworkPackageDescriptorCommandInput extends GetSolNetworkPackageDescriptorInput {
+}
+export interface GetSolNetworkPackageDescriptorCommandOutput extends GetSolNetworkPackageDescriptorOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets the content of the network service descriptor.</p>
+ *          <p>A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network functions on.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, GetSolNetworkPackageDescriptorCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, GetSolNetworkPackageDescriptorCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new GetSolNetworkPackageDescriptorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSolNetworkPackageDescriptorCommandInput} for command's `input` shape.
+ * @see {@link GetSolNetworkPackageDescriptorCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class GetSolNetworkPackageDescriptorCommand extends $Command<GetSolNetworkPackageDescriptorCommandInput, GetSolNetworkPackageDescriptorCommandOutput, TnbClientResolvedConfig> {
+    readonly input: GetSolNetworkPackageDescriptorCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSolNetworkPackageDescriptorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSolNetworkPackageDescriptorCommandInput, GetSolNetworkPackageDescriptorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/InstantiateSolNetworkInstanceCommand.d.ts

@@ -0,0 +1,39 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { InstantiateSolNetworkInstanceInput, InstantiateSolNetworkInstanceOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface InstantiateSolNetworkInstanceCommandInput extends InstantiateSolNetworkInstanceInput {
+}
+export interface InstantiateSolNetworkInstanceCommandOutput extends InstantiateSolNetworkInstanceOutput, __MetadataBearer {
+}
+/**
+ * <p>Instantiates a network instance.</p>
+ *          <p>A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.</p>
+ *          <p>Before you can instantiate a network instance, you have to create a network instance. For more information, see <a href="https://docs.aws.amazon.com/TNB/latest/APIReference/API_CreateSolNetworkInstance.html">CreateSolNetworkInstance</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, InstantiateSolNetworkInstanceCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, InstantiateSolNetworkInstanceCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new InstantiateSolNetworkInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link InstantiateSolNetworkInstanceCommandInput} for command's `input` shape.
+ * @see {@link InstantiateSolNetworkInstanceCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class InstantiateSolNetworkInstanceCommand extends $Command<InstantiateSolNetworkInstanceCommandInput, InstantiateSolNetworkInstanceCommandOutput, TnbClientResolvedConfig> {
+    readonly input: InstantiateSolNetworkInstanceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: InstantiateSolNetworkInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<InstantiateSolNetworkInstanceCommandInput, InstantiateSolNetworkInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSolFunctionInstancesCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListSolFunctionInstancesInput, ListSolFunctionInstancesOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface ListSolFunctionInstancesCommandInput extends ListSolFunctionInstancesInput {
+}
+export interface ListSolFunctionInstancesCommandOutput extends ListSolFunctionInstancesOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists network function instances.</p>
+ *          <p>A network function instance is a function in a function package .</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, ListSolFunctionInstancesCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, ListSolFunctionInstancesCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new ListSolFunctionInstancesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSolFunctionInstancesCommandInput} for command's `input` shape.
+ * @see {@link ListSolFunctionInstancesCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class ListSolFunctionInstancesCommand extends $Command<ListSolFunctionInstancesCommandInput, ListSolFunctionInstancesCommandOutput, TnbClientResolvedConfig> {
+    readonly input: ListSolFunctionInstancesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListSolFunctionInstancesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSolFunctionInstancesCommandInput, ListSolFunctionInstancesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSolFunctionPackagesCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListSolFunctionPackagesInput, ListSolFunctionPackagesOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface ListSolFunctionPackagesCommandInput extends ListSolFunctionPackagesInput {
+}
+export interface ListSolFunctionPackagesCommandOutput extends ListSolFunctionPackagesOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists information about function packages.</p>
+ *          <p>A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, ListSolFunctionPackagesCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, ListSolFunctionPackagesCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new ListSolFunctionPackagesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSolFunctionPackagesCommandInput} for command's `input` shape.
+ * @see {@link ListSolFunctionPackagesCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class ListSolFunctionPackagesCommand extends $Command<ListSolFunctionPackagesCommandInput, ListSolFunctionPackagesCommandOutput, TnbClientResolvedConfig> {
+    readonly input: ListSolFunctionPackagesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListSolFunctionPackagesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSolFunctionPackagesCommandInput, ListSolFunctionPackagesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSolNetworkInstancesCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListSolNetworkInstancesInput, ListSolNetworkInstancesOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface ListSolNetworkInstancesCommandInput extends ListSolNetworkInstancesInput {
+}
+export interface ListSolNetworkInstancesCommandOutput extends ListSolNetworkInstancesOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists your network instances.</p>
+ *          <p>A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, ListSolNetworkInstancesCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, ListSolNetworkInstancesCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new ListSolNetworkInstancesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSolNetworkInstancesCommandInput} for command's `input` shape.
+ * @see {@link ListSolNetworkInstancesCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class ListSolNetworkInstancesCommand extends $Command<ListSolNetworkInstancesCommandInput, ListSolNetworkInstancesCommandOutput, TnbClientResolvedConfig> {
+    readonly input: ListSolNetworkInstancesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListSolNetworkInstancesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSolNetworkInstancesCommandInput, ListSolNetworkInstancesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSolNetworkOperationsCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListSolNetworkOperationsInput, ListSolNetworkOperationsOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface ListSolNetworkOperationsCommandInput extends ListSolNetworkOperationsInput {
+}
+export interface ListSolNetworkOperationsCommandOutput extends ListSolNetworkOperationsOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists details for a network operation, including when the operation started and the status of the operation.</p>
+ *          <p>A network operation is any operation that is done to your network, such as network instance instantiation or termination.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, ListSolNetworkOperationsCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, ListSolNetworkOperationsCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new ListSolNetworkOperationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSolNetworkOperationsCommandInput} for command's `input` shape.
+ * @see {@link ListSolNetworkOperationsCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class ListSolNetworkOperationsCommand extends $Command<ListSolNetworkOperationsCommandInput, ListSolNetworkOperationsCommandOutput, TnbClientResolvedConfig> {
+    readonly input: ListSolNetworkOperationsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListSolNetworkOperationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSolNetworkOperationsCommandInput, ListSolNetworkOperationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSolNetworkPackagesCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListSolNetworkPackagesInput, ListSolNetworkPackagesOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface ListSolNetworkPackagesCommandInput extends ListSolNetworkPackagesInput {
+}
+export interface ListSolNetworkPackagesCommandOutput extends ListSolNetworkPackagesOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists network packages.</p>
+ *          <p>A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, ListSolNetworkPackagesCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, ListSolNetworkPackagesCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new ListSolNetworkPackagesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSolNetworkPackagesCommandInput} for command's `input` shape.
+ * @see {@link ListSolNetworkPackagesCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class ListSolNetworkPackagesCommand extends $Command<ListSolNetworkPackagesCommandInput, ListSolNetworkPackagesCommandOutput, TnbClientResolvedConfig> {
+    readonly input: ListSolNetworkPackagesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListSolNetworkPackagesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSolNetworkPackagesCommandInput, ListSolNetworkPackagesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListTagsForResourceInput, ListTagsForResourceOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceInput {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists tags for AWS TNB resources.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, ListTagsForResourceCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, ListTagsForResourceCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, TnbClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutSolFunctionPackageContentCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutSolFunctionPackageContentInput, PutSolFunctionPackageContentOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface PutSolFunctionPackageContentCommandInput extends PutSolFunctionPackageContentInput {
+}
+export interface PutSolFunctionPackageContentCommandOutput extends PutSolFunctionPackageContentOutput, __MetadataBearer {
+}
+/**
+ * <p>Uploads the contents of a function package.</p>
+ *          <p>A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, PutSolFunctionPackageContentCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, PutSolFunctionPackageContentCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new PutSolFunctionPackageContentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutSolFunctionPackageContentCommandInput} for command's `input` shape.
+ * @see {@link PutSolFunctionPackageContentCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class PutSolFunctionPackageContentCommand extends $Command<PutSolFunctionPackageContentCommandInput, PutSolFunctionPackageContentCommandOutput, TnbClientResolvedConfig> {
+    readonly input: PutSolFunctionPackageContentCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: PutSolFunctionPackageContentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutSolFunctionPackageContentCommandInput, PutSolFunctionPackageContentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutSolNetworkPackageContentCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { PutSolNetworkPackageContentInput, PutSolNetworkPackageContentOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface PutSolNetworkPackageContentCommandInput extends PutSolNetworkPackageContentInput {
+}
+export interface PutSolNetworkPackageContentCommandOutput extends PutSolNetworkPackageContentOutput, __MetadataBearer {
+}
+/**
+ * <p>Uploads the contents of a network package.</p>
+ *          <p>A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, PutSolNetworkPackageContentCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, PutSolNetworkPackageContentCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new PutSolNetworkPackageContentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutSolNetworkPackageContentCommandInput} for command's `input` shape.
+ * @see {@link PutSolNetworkPackageContentCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class PutSolNetworkPackageContentCommand extends $Command<PutSolNetworkPackageContentCommandInput, PutSolNetworkPackageContentCommandOutput, TnbClientResolvedConfig> {
+    readonly input: PutSolNetworkPackageContentCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: PutSolNetworkPackageContentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutSolNetworkPackageContentCommandInput, PutSolNetworkPackageContentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TagResourceCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { TagResourceInput, TagResourceOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface TagResourceCommandInput extends TagResourceInput {
+}
+export interface TagResourceCommandOutput extends TagResourceOutput, __MetadataBearer {
+}
+/**
+ * <p>Tags an AWS TNB resource.</p>
+ *          <p>A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, TagResourceCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, TagResourceCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, TnbClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TerminateSolNetworkInstanceCommand.d.ts

@@ -0,0 +1,39 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { TerminateSolNetworkInstanceInput, TerminateSolNetworkInstanceOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface TerminateSolNetworkInstanceCommandInput extends TerminateSolNetworkInstanceInput {
+}
+export interface TerminateSolNetworkInstanceCommandOutput extends TerminateSolNetworkInstanceOutput, __MetadataBearer {
+}
+/**
+ * <p>Terminates a network instance.</p>
+ *          <p>A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.</p>
+ *          <p>You must terminate a network instance before you can delete it.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, TerminateSolNetworkInstanceCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, TerminateSolNetworkInstanceCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new TerminateSolNetworkInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TerminateSolNetworkInstanceCommandInput} for command's `input` shape.
+ * @see {@link TerminateSolNetworkInstanceCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class TerminateSolNetworkInstanceCommand extends $Command<TerminateSolNetworkInstanceCommandInput, TerminateSolNetworkInstanceCommandOutput, TnbClientResolvedConfig> {
+    readonly input: TerminateSolNetworkInstanceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: TerminateSolNetworkInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TerminateSolNetworkInstanceCommandInput, TerminateSolNetworkInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UntagResourceCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UntagResourceInput, UntagResourceOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface UntagResourceCommandInput extends UntagResourceInput {
+}
+export interface UntagResourceCommandOutput extends UntagResourceOutput, __MetadataBearer {
+}
+/**
+ * <p>Untags an AWS TNB resource.</p>
+ *          <p>A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional value. You can use tags to search and filter your resources or track your Amazon Web Services costs.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, UntagResourceCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, UntagResourceCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new UntagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UntagResourceCommandInput} for command's `input` shape.
+ * @see {@link UntagResourceCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, TnbClientResolvedConfig> {
+    readonly input: UntagResourceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UntagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateSolFunctionPackageCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateSolFunctionPackageInput, UpdateSolFunctionPackageOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface UpdateSolFunctionPackageCommandInput extends UpdateSolFunctionPackageInput {
+}
+export interface UpdateSolFunctionPackageCommandOutput extends UpdateSolFunctionPackageOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates the operational state of function package.</p>
+ *          <p>A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to describe how the network functions should run on your network.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, UpdateSolFunctionPackageCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, UpdateSolFunctionPackageCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new UpdateSolFunctionPackageCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateSolFunctionPackageCommandInput} for command's `input` shape.
+ * @see {@link UpdateSolFunctionPackageCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class UpdateSolFunctionPackageCommand extends $Command<UpdateSolFunctionPackageCommandInput, UpdateSolFunctionPackageCommandOutput, TnbClientResolvedConfig> {
+    readonly input: UpdateSolFunctionPackageCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UpdateSolFunctionPackageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateSolFunctionPackageCommandInput, UpdateSolFunctionPackageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateSolNetworkInstanceCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateSolNetworkInstanceInput, UpdateSolNetworkInstanceOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface UpdateSolNetworkInstanceCommandInput extends UpdateSolNetworkInstanceInput {
+}
+export interface UpdateSolNetworkInstanceCommandOutput extends UpdateSolNetworkInstanceOutput, __MetadataBearer {
+}
+/**
+ * <p>Update a network instance.</p>
+ *          <p>A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which life-cycle operations (like terminate, update, and delete) can be performed.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, UpdateSolNetworkInstanceCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, UpdateSolNetworkInstanceCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new UpdateSolNetworkInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateSolNetworkInstanceCommandInput} for command's `input` shape.
+ * @see {@link UpdateSolNetworkInstanceCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class UpdateSolNetworkInstanceCommand extends $Command<UpdateSolNetworkInstanceCommandInput, UpdateSolNetworkInstanceCommandOutput, TnbClientResolvedConfig> {
+    readonly input: UpdateSolNetworkInstanceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UpdateSolNetworkInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateSolNetworkInstanceCommandInput, UpdateSolNetworkInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateSolNetworkPackageCommand.d.ts

@@ -0,0 +1,39 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateSolNetworkPackageInput, UpdateSolNetworkPackageOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface UpdateSolNetworkPackageCommandInput extends UpdateSolNetworkPackageInput {
+}
+export interface UpdateSolNetworkPackageCommandOutput extends UpdateSolNetworkPackageOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates the operational state of a network package.</p>
+ *          <p>A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to deploy and the Amazon Web Services infrastructure you want to deploy them on.</p>
+ *          <p>A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network functions on.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, UpdateSolNetworkPackageCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, UpdateSolNetworkPackageCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new UpdateSolNetworkPackageCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateSolNetworkPackageCommandInput} for command's `input` shape.
+ * @see {@link UpdateSolNetworkPackageCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class UpdateSolNetworkPackageCommand extends $Command<UpdateSolNetworkPackageCommandInput, UpdateSolNetworkPackageCommandOutput, TnbClientResolvedConfig> {
+    readonly input: UpdateSolNetworkPackageCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UpdateSolNetworkPackageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateSolNetworkPackageCommandInput, UpdateSolNetworkPackageCommandOutput>;
+    private serialize;
+    private deserialize;
+}