@aws-sdk/client-tnb 3.276.0

package/dist-types/commands/CancelSolNetworkOperationCommand.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 { CancelSolNetworkOperationInput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface CancelSolNetworkOperationCommandInput extends CancelSolNetworkOperationInput {
+}
+export interface CancelSolNetworkOperationCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Cancels a network 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, CancelSolNetworkOperationCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, CancelSolNetworkOperationCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new CancelSolNetworkOperationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CancelSolNetworkOperationCommandInput} for command's `input` shape.
+ * @see {@link CancelSolNetworkOperationCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class CancelSolNetworkOperationCommand extends $Command<CancelSolNetworkOperationCommandInput, CancelSolNetworkOperationCommandOutput, TnbClientResolvedConfig> {
+    readonly input: CancelSolNetworkOperationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CancelSolNetworkOperationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CancelSolNetworkOperationCommandInput, CancelSolNetworkOperationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+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 { CreateSolFunctionPackageInput, CreateSolFunctionPackageOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface CreateSolFunctionPackageCommandInput extends CreateSolFunctionPackageInput {
+}
+export interface CreateSolFunctionPackageCommandOutput extends CreateSolFunctionPackageOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates 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. For more information, see <a href="https://docs.aws.amazon.com/tnb/latest/ug/function-packages.html">Function packages</a> in the <i>Amazon Web Services Telco Network Builder User Guide</i>.
+ *       </p>
+ *          <p>Creating a function package is the first step for creating a network in AWS TNB. This request creates an empty container with an ID. The next step is to upload the actual CSAR zip file into that empty container. To upload function package content, see <a href="https://docs.aws.amazon.com/TNB/latest/APIReference/API_PutSolFunctionPackageContent.html">PutSolFunctionPackageContent</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, CreateSolFunctionPackageCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, CreateSolFunctionPackageCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new CreateSolFunctionPackageCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateSolFunctionPackageCommandInput} for command's `input` shape.
+ * @see {@link CreateSolFunctionPackageCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class CreateSolFunctionPackageCommand extends $Command<CreateSolFunctionPackageCommandInput, CreateSolFunctionPackageCommandOutput, TnbClientResolvedConfig> {
+    readonly input: CreateSolFunctionPackageCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateSolFunctionPackageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSolFunctionPackageCommandInput, CreateSolFunctionPackageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateSolNetworkInstanceCommand.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 { CreateSolNetworkInstanceInput, CreateSolNetworkInstanceOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface CreateSolNetworkInstanceCommandInput extends CreateSolNetworkInstanceInput {
+}
+export interface CreateSolNetworkInstanceCommandOutput extends CreateSolNetworkInstanceOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates 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. Creating a network instance is the third step after creating a network package. For more information about network instances, <a href="https://docs.aws.amazon.com/tnb/latest/ug/network-instances.html">Network instances</a> in the <i>Amazon Web Services Telco Network Builder User Guide</i>.</p>
+ *          <p>Once you create a network instance, you can instantiate it. To instantiate a network, see <a href="https://docs.aws.amazon.com/TNB/latest/APIReference/API_InstantiateSolNetworkInstance.html">InstantiateSolNetworkInstance</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, CreateSolNetworkInstanceCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, CreateSolNetworkInstanceCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new CreateSolNetworkInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateSolNetworkInstanceCommandInput} for command's `input` shape.
+ * @see {@link CreateSolNetworkInstanceCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class CreateSolNetworkInstanceCommand extends $Command<CreateSolNetworkInstanceCommandInput, CreateSolNetworkInstanceCommandOutput, TnbClientResolvedConfig> {
+    readonly input: CreateSolNetworkInstanceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateSolNetworkInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSolNetworkInstanceCommandInput, CreateSolNetworkInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,41 @@
+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 { CreateSolNetworkPackageInput, CreateSolNetworkPackageOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface CreateSolNetworkPackageCommandInput extends CreateSolNetworkPackageInput {
+}
+export interface CreateSolNetworkPackageCommandOutput extends CreateSolNetworkPackageOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates 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. For more information, see <a href="https://docs.aws.amazon.com/tnb/latest/ug/network-instances.html">Network instances</a> in the <i>Amazon Web Services Telco Network Builder User Guide</i>.
+ *       </p>
+ *          <p>A network package consists of a network service descriptor (NSD) file (required) and any additional files (optional), such as scripts specific to your needs. For example, if you have multiple function packages in your network package, you can use the NSD to define which network functions should run in certain VPCs, subnets, or EKS clusters.</p>
+ *          <p>This request creates an empty network package container with an ID. Once you create a network package, you can upload the network package content using <a href="https://docs.aws.amazon.com/TNB/latest/APIReference/API_PutSolNetworkPackageContent.html">PutSolNetworkPackageContent</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, CreateSolNetworkPackageCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, CreateSolNetworkPackageCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new CreateSolNetworkPackageCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateSolNetworkPackageCommandInput} for command's `input` shape.
+ * @see {@link CreateSolNetworkPackageCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class CreateSolNetworkPackageCommand extends $Command<CreateSolNetworkPackageCommandInput, CreateSolNetworkPackageCommandOutput, TnbClientResolvedConfig> {
+    readonly input: CreateSolNetworkPackageCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: CreateSolNetworkPackageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSolNetworkPackageCommandInput, CreateSolNetworkPackageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+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 { DeleteSolFunctionPackageInput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface DeleteSolFunctionPackageCommandInput extends DeleteSolFunctionPackageInput {
+}
+export interface DeleteSolFunctionPackageCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes 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>
+ *          <p>To delete a function package, the package must be in a disabled state. To disable a function package, see <a href="https://docs.aws.amazon.com/TNB/latest/APIReference/API_UpdateSolFunctionPackage.html">UpdateSolFunctionPackage</a>.
+ *       </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, DeleteSolFunctionPackageCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, DeleteSolFunctionPackageCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new DeleteSolFunctionPackageCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSolFunctionPackageCommandInput} for command's `input` shape.
+ * @see {@link DeleteSolFunctionPackageCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class DeleteSolFunctionPackageCommand extends $Command<DeleteSolFunctionPackageCommandInput, DeleteSolFunctionPackageCommandOutput, TnbClientResolvedConfig> {
+    readonly input: DeleteSolFunctionPackageCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteSolFunctionPackageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSolFunctionPackageCommandInput, DeleteSolFunctionPackageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteSolNetworkInstanceCommand.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 { DeleteSolNetworkInstanceInput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface DeleteSolNetworkInstanceCommandInput extends DeleteSolNetworkInstanceInput {
+}
+export interface DeleteSolNetworkInstanceCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes 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>To delete a network instance, the instance must be in a stopped or terminated state. To terminate a network instance, see <a href="https://docs.aws.amazon.com/TNB/latest/APIReference/API_TerminateSolNetworkInstance.html">TerminateSolNetworkInstance</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, DeleteSolNetworkInstanceCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, DeleteSolNetworkInstanceCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new DeleteSolNetworkInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSolNetworkInstanceCommandInput} for command's `input` shape.
+ * @see {@link DeleteSolNetworkInstanceCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class DeleteSolNetworkInstanceCommand extends $Command<DeleteSolNetworkInstanceCommandInput, DeleteSolNetworkInstanceCommandOutput, TnbClientResolvedConfig> {
+    readonly input: DeleteSolNetworkInstanceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteSolNetworkInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSolNetworkInstanceCommandInput, DeleteSolNetworkInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteSolNetworkPackageCommand.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 { DeleteSolNetworkPackageInput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface DeleteSolNetworkPackageCommandInput extends DeleteSolNetworkPackageInput {
+}
+export interface DeleteSolNetworkPackageCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Deletes 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>To delete a network package, the package must be in a disable state. To disable a network package, see <a href="https://docs.aws.amazon.com/TNB/latest/APIReference/API_UpdateSolNetworkPackage.html">UpdateSolNetworkPackage</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { TnbClient, DeleteSolNetworkPackageCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, DeleteSolNetworkPackageCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new DeleteSolNetworkPackageCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSolNetworkPackageCommandInput} for command's `input` shape.
+ * @see {@link DeleteSolNetworkPackageCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class DeleteSolNetworkPackageCommand extends $Command<DeleteSolNetworkPackageCommandInput, DeleteSolNetworkPackageCommandOutput, TnbClientResolvedConfig> {
+    readonly input: DeleteSolNetworkPackageCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: DeleteSolNetworkPackageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSolNetworkPackageCommandInput, DeleteSolNetworkPackageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSolFunctionInstanceCommand.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 { GetSolFunctionInstanceInput, GetSolFunctionInstanceOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface GetSolFunctionInstanceCommandInput extends GetSolFunctionInstanceInput {
+}
+export interface GetSolFunctionInstanceCommandOutput extends GetSolFunctionInstanceOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets the details of a network function instance, including the instantation state and metadata from the function package descriptor in the network function package.</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, GetSolFunctionInstanceCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, GetSolFunctionInstanceCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new GetSolFunctionInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSolFunctionInstanceCommandInput} for command's `input` shape.
+ * @see {@link GetSolFunctionInstanceCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class GetSolFunctionInstanceCommand extends $Command<GetSolFunctionInstanceCommandInput, GetSolFunctionInstanceCommandOutput, TnbClientResolvedConfig> {
+    readonly input: GetSolFunctionInstanceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSolFunctionInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSolFunctionInstanceCommandInput, GetSolFunctionInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSolFunctionPackageCommand.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 { GetSolFunctionPackageInput, GetSolFunctionPackageOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface GetSolFunctionPackageCommandInput extends GetSolFunctionPackageInput {
+}
+export interface GetSolFunctionPackageCommandOutput extends GetSolFunctionPackageOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets the details of an individual function package, such as the operational state and whether the package is in use.</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, GetSolFunctionPackageCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, GetSolFunctionPackageCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new GetSolFunctionPackageCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSolFunctionPackageCommandInput} for command's `input` shape.
+ * @see {@link GetSolFunctionPackageCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class GetSolFunctionPackageCommand extends $Command<GetSolFunctionPackageCommandInput, GetSolFunctionPackageCommandOutput, TnbClientResolvedConfig> {
+    readonly input: GetSolFunctionPackageCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSolFunctionPackageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSolFunctionPackageCommandInput, GetSolFunctionPackageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSolFunctionPackageContentCommand.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 { GetSolFunctionPackageContentInput, GetSolFunctionPackageContentOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface GetSolFunctionPackageContentCommandInput extends GetSolFunctionPackageContentInput {
+}
+export interface GetSolFunctionPackageContentCommandOutput extends GetSolFunctionPackageContentOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets 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, GetSolFunctionPackageContentCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, GetSolFunctionPackageContentCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new GetSolFunctionPackageContentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSolFunctionPackageContentCommandInput} for command's `input` shape.
+ * @see {@link GetSolFunctionPackageContentCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class GetSolFunctionPackageContentCommand extends $Command<GetSolFunctionPackageContentCommandInput, GetSolFunctionPackageContentCommandOutput, TnbClientResolvedConfig> {
+    readonly input: GetSolFunctionPackageContentCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSolFunctionPackageContentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSolFunctionPackageContentCommandInput, GetSolFunctionPackageContentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSolFunctionPackageDescriptorCommand.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 { GetSolFunctionPackageDescriptorInput, GetSolFunctionPackageDescriptorOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface GetSolFunctionPackageDescriptorCommandInput extends GetSolFunctionPackageDescriptorInput {
+}
+export interface GetSolFunctionPackageDescriptorCommandOutput extends GetSolFunctionPackageDescriptorOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets a function package descriptor in a function package.</p>
+ *          <p>A function package descriptor is a .yaml file in a function package that uses the TOSCA standard to describe how the network function in the function package should run on your network.</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, GetSolFunctionPackageDescriptorCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, GetSolFunctionPackageDescriptorCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new GetSolFunctionPackageDescriptorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSolFunctionPackageDescriptorCommandInput} for command's `input` shape.
+ * @see {@link GetSolFunctionPackageDescriptorCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class GetSolFunctionPackageDescriptorCommand extends $Command<GetSolFunctionPackageDescriptorCommandInput, GetSolFunctionPackageDescriptorCommandOutput, TnbClientResolvedConfig> {
+    readonly input: GetSolFunctionPackageDescriptorCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSolFunctionPackageDescriptorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSolFunctionPackageDescriptorCommandInput, GetSolFunctionPackageDescriptorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSolNetworkInstanceCommand.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 { GetSolNetworkInstanceInput, GetSolNetworkInstanceOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface GetSolNetworkInstanceCommandInput extends GetSolNetworkInstanceInput {
+}
+export interface GetSolNetworkInstanceCommandOutput extends GetSolNetworkInstanceOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets the details of the 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, GetSolNetworkInstanceCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, GetSolNetworkInstanceCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new GetSolNetworkInstanceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSolNetworkInstanceCommandInput} for command's `input` shape.
+ * @see {@link GetSolNetworkInstanceCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class GetSolNetworkInstanceCommand extends $Command<GetSolNetworkInstanceCommandInput, GetSolNetworkInstanceCommandOutput, TnbClientResolvedConfig> {
+    readonly input: GetSolNetworkInstanceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSolNetworkInstanceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSolNetworkInstanceCommandInput, GetSolNetworkInstanceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSolNetworkOperationCommand.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 { GetSolNetworkOperationInput, GetSolNetworkOperationOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface GetSolNetworkOperationCommandInput extends GetSolNetworkOperationInput {
+}
+export interface GetSolNetworkOperationCommandOutput extends GetSolNetworkOperationOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets the details of a network operation, including the tasks involved in the network operation and the status of the tasks.</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, GetSolNetworkOperationCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, GetSolNetworkOperationCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new GetSolNetworkOperationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSolNetworkOperationCommandInput} for command's `input` shape.
+ * @see {@link GetSolNetworkOperationCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class GetSolNetworkOperationCommand extends $Command<GetSolNetworkOperationCommandInput, GetSolNetworkOperationCommandOutput, TnbClientResolvedConfig> {
+    readonly input: GetSolNetworkOperationCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSolNetworkOperationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSolNetworkOperationCommandInput, GetSolNetworkOperationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSolNetworkPackageCommand.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 { GetSolNetworkPackageInput, GetSolNetworkPackageOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface GetSolNetworkPackageCommandInput extends GetSolNetworkPackageInput {
+}
+export interface GetSolNetworkPackageCommandOutput extends GetSolNetworkPackageOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets the details 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, GetSolNetworkPackageCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, GetSolNetworkPackageCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new GetSolNetworkPackageCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSolNetworkPackageCommandInput} for command's `input` shape.
+ * @see {@link GetSolNetworkPackageCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class GetSolNetworkPackageCommand extends $Command<GetSolNetworkPackageCommandInput, GetSolNetworkPackageCommandOutput, TnbClientResolvedConfig> {
+    readonly input: GetSolNetworkPackageCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSolNetworkPackageCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSolNetworkPackageCommandInput, GetSolNetworkPackageCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSolNetworkPackageContentCommand.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 { GetSolNetworkPackageContentInput, GetSolNetworkPackageContentOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, TnbClientResolvedConfig } from "../TnbClient";
+export interface GetSolNetworkPackageContentCommandInput extends GetSolNetworkPackageContentInput {
+}
+export interface GetSolNetworkPackageContentCommandOutput extends GetSolNetworkPackageContentOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets 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, GetSolNetworkPackageContentCommand } from "@aws-sdk/client-tnb"; // ES Modules import
+ * // const { TnbClient, GetSolNetworkPackageContentCommand } = require("@aws-sdk/client-tnb"); // CommonJS import
+ * const client = new TnbClient(config);
+ * const command = new GetSolNetworkPackageContentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSolNetworkPackageContentCommandInput} for command's `input` shape.
+ * @see {@link GetSolNetworkPackageContentCommandOutput} for command's `response` shape.
+ * @see {@link TnbClientResolvedConfig | config} for TnbClient's `config` shape.
+ *
+ */
+export declare class GetSolNetworkPackageContentCommand extends $Command<GetSolNetworkPackageContentCommandInput, GetSolNetworkPackageContentCommandOutput, TnbClientResolvedConfig> {
+    readonly input: GetSolNetworkPackageContentCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSolNetworkPackageContentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: TnbClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSolNetworkPackageContentCommandInput, GetSolNetworkPackageContentCommandOutput>;
+    private serialize;
+    private deserialize;
+}