@aws-sdk/client-networkmanager 3.295.0 → 3.297.0

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateLinkRequest, CreateLinkResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link CreateLinkCommand}.
  */
 export interface CreateLinkCommandInput extends CreateLinkRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateLinkCommand}.
  */
 export interface CreateLinkCommandOutput extends CreateLinkResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new link for a specified site.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateLinkCommandOutput extends CreateLinkResponse, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateLinkCommandInput - {@link CreateLinkCommandInput}
+ * @returns {@link CreateLinkCommandOutput}
  * @see {@link CreateLinkCommandInput} for command's `input` shape.
  * @see {@link CreateLinkCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -56,11 +63,20 @@ export interface CreateLinkCommandOutput extends CreateLinkResponse, __MetadataB
 export declare class CreateLinkCommand extends $Command<CreateLinkCommandInput, CreateLinkCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: CreateLinkCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateLinkCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLinkCommandInput, CreateLinkCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateSiteRequest, CreateSiteResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link CreateSiteCommand}.
  */
 export interface CreateSiteCommandInput extends CreateSiteRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateSiteCommand}.
  */
 export interface CreateSiteCommandOutput extends CreateSiteResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a new site in a global network.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateSiteCommandOutput extends CreateSiteResponse, __MetadataB
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateSiteCommandInput - {@link CreateSiteCommandInput}
+ * @returns {@link CreateSiteCommandOutput}
  * @see {@link CreateSiteCommandInput} for command's `input` shape.
  * @see {@link CreateSiteCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -56,11 +63,20 @@ export interface CreateSiteCommandOutput extends CreateSiteResponse, __MetadataB
 export declare class CreateSiteCommand extends $Command<CreateSiteCommandInput, CreateSiteCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: CreateSiteCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateSiteCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSiteCommandInput, CreateSiteCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateSiteToSiteVpnAttachmentRequest, CreateSiteToSiteVpnAttachmentResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link CreateSiteToSiteVpnAttachmentCommand}.
  */
 export interface CreateSiteToSiteVpnAttachmentCommandInput extends CreateSiteToSiteVpnAttachmentRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateSiteToSiteVpnAttachmentCommand}.
  */
 export interface CreateSiteToSiteVpnAttachmentCommandOutput extends CreateSiteToSiteVpnAttachmentResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates an Amazon Web Services site-to-site VPN attachment on an edge location of a core network.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateSiteToSiteVpnAttachmentCommandOutput extends CreateSiteTo
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateSiteToSiteVpnAttachmentCommandInput - {@link CreateSiteToSiteVpnAttachmentCommandInput}
+ * @returns {@link CreateSiteToSiteVpnAttachmentCommandOutput}
  * @see {@link CreateSiteToSiteVpnAttachmentCommandInput} for command's `input` shape.
  * @see {@link CreateSiteToSiteVpnAttachmentCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface CreateSiteToSiteVpnAttachmentCommandOutput extends CreateSiteTo
 export declare class CreateSiteToSiteVpnAttachmentCommand extends $Command<CreateSiteToSiteVpnAttachmentCommandInput, CreateSiteToSiteVpnAttachmentCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: CreateSiteToSiteVpnAttachmentCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateSiteToSiteVpnAttachmentCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSiteToSiteVpnAttachmentCommandInput, CreateSiteToSiteVpnAttachmentCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateTransitGatewayPeeringRequest, CreateTransitGatewayPeeringResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link CreateTransitGatewayPeeringCommand}.
  */
 export interface CreateTransitGatewayPeeringCommandInput extends CreateTransitGatewayPeeringRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTransitGatewayPeeringCommand}.
  */
 export interface CreateTransitGatewayPeeringCommandOutput extends CreateTransitGatewayPeeringResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a transit gateway peering connection.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateTransitGatewayPeeringCommandOutput extends CreateTransitG
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTransitGatewayPeeringCommandInput - {@link CreateTransitGatewayPeeringCommandInput}
+ * @returns {@link CreateTransitGatewayPeeringCommandOutput}
  * @see {@link CreateTransitGatewayPeeringCommandInput} for command's `input` shape.
  * @see {@link CreateTransitGatewayPeeringCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface CreateTransitGatewayPeeringCommandOutput extends CreateTransitG
 export declare class CreateTransitGatewayPeeringCommand extends $Command<CreateTransitGatewayPeeringCommandInput, CreateTransitGatewayPeeringCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: CreateTransitGatewayPeeringCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTransitGatewayPeeringCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayPeeringCommandInput, CreateTransitGatewayPeeringCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateTransitGatewayRouteTableAttachmentRequest, CreateTransitGatewayRouteTableAttachmentResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link CreateTransitGatewayRouteTableAttachmentCommand}.
  */
 export interface CreateTransitGatewayRouteTableAttachmentCommandInput extends CreateTransitGatewayRouteTableAttachmentRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateTransitGatewayRouteTableAttachmentCommand}.
  */
 export interface CreateTransitGatewayRouteTableAttachmentCommandOutput extends CreateTransitGatewayRouteTableAttachmentResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a transit gateway route table attachment.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateTransitGatewayRouteTableAttachmentCommandOutput extends C
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateTransitGatewayRouteTableAttachmentCommandInput - {@link CreateTransitGatewayRouteTableAttachmentCommandInput}
+ * @returns {@link CreateTransitGatewayRouteTableAttachmentCommandOutput}
  * @see {@link CreateTransitGatewayRouteTableAttachmentCommandInput} for command's `input` shape.
  * @see {@link CreateTransitGatewayRouteTableAttachmentCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface CreateTransitGatewayRouteTableAttachmentCommandOutput extends C
 export declare class CreateTransitGatewayRouteTableAttachmentCommand extends $Command<CreateTransitGatewayRouteTableAttachmentCommandInput, CreateTransitGatewayRouteTableAttachmentCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: CreateTransitGatewayRouteTableAttachmentCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateTransitGatewayRouteTableAttachmentCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTransitGatewayRouteTableAttachmentCommandInput, CreateTransitGatewayRouteTableAttachmentCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { CreateVpcAttachmentRequest, CreateVpcAttachmentResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link CreateVpcAttachmentCommand}.
  */
 export interface CreateVpcAttachmentCommandInput extends CreateVpcAttachmentRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link CreateVpcAttachmentCommand}.
  */
 export interface CreateVpcAttachmentCommandOutput extends CreateVpcAttachmentResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Creates a VPC attachment on an edge location of a core network.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface CreateVpcAttachmentCommandOutput extends CreateVpcAttachmentRes
  * const response = await client.send(command);
  * ```
  *
+ * @param CreateVpcAttachmentCommandInput - {@link CreateVpcAttachmentCommandInput}
+ * @returns {@link CreateVpcAttachmentCommandOutput}
  * @see {@link CreateVpcAttachmentCommandInput} for command's `input` shape.
  * @see {@link CreateVpcAttachmentCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface CreateVpcAttachmentCommandOutput extends CreateVpcAttachmentRes
 export declare class CreateVpcAttachmentCommand extends $Command<CreateVpcAttachmentCommandInput, CreateVpcAttachmentCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: CreateVpcAttachmentCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: CreateVpcAttachmentCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateVpcAttachmentCommandInput, CreateVpcAttachmentCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteAttachmentRequest, DeleteAttachmentResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteAttachmentCommand}.
  */
 export interface DeleteAttachmentCommandInput extends DeleteAttachmentRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteAttachmentCommand}.
  */
 export interface DeleteAttachmentCommandOutput extends DeleteAttachmentResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes an attachment. Supports all attachment types.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteAttachmentCommandOutput extends DeleteAttachmentResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteAttachmentCommandInput - {@link DeleteAttachmentCommandInput}
+ * @returns {@link DeleteAttachmentCommandOutput}
  * @see {@link DeleteAttachmentCommandInput} for command's `input` shape.
  * @see {@link DeleteAttachmentCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface DeleteAttachmentCommandOutput extends DeleteAttachmentResponse,
 export declare class DeleteAttachmentCommand extends $Command<DeleteAttachmentCommandInput, DeleteAttachmentCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: DeleteAttachmentCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteAttachmentCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteAttachmentCommandInput, DeleteAttachmentCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteConnectPeerRequest, DeleteConnectPeerResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteConnectPeerCommand}.
  */
 export interface DeleteConnectPeerCommandInput extends DeleteConnectPeerRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteConnectPeerCommand}.
  */
 export interface DeleteConnectPeerCommandOutput extends DeleteConnectPeerResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a Connect peer.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteConnectPeerCommandOutput extends DeleteConnectPeerRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteConnectPeerCommandInput - {@link DeleteConnectPeerCommandInput}
+ * @returns {@link DeleteConnectPeerCommandOutput}
  * @see {@link DeleteConnectPeerCommandInput} for command's `input` shape.
  * @see {@link DeleteConnectPeerCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface DeleteConnectPeerCommandOutput extends DeleteConnectPeerRespons
 export declare class DeleteConnectPeerCommand extends $Command<DeleteConnectPeerCommandInput, DeleteConnectPeerCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: DeleteConnectPeerCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteConnectPeerCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConnectPeerCommandInput, DeleteConnectPeerCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteConnectionRequest, DeleteConnectionResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteConnectionCommand}.
  */
 export interface DeleteConnectionCommandInput extends DeleteConnectionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteConnectionCommand}.
  */
 export interface DeleteConnectionCommandOutput extends DeleteConnectionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes the specified connection in your global network.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteConnectionCommandOutput extends DeleteConnectionResponse,
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteConnectionCommandInput - {@link DeleteConnectionCommandInput}
+ * @returns {@link DeleteConnectionCommandOutput}
  * @see {@link DeleteConnectionCommandInput} for command's `input` shape.
  * @see {@link DeleteConnectionCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface DeleteConnectionCommandOutput extends DeleteConnectionResponse,
 export declare class DeleteConnectionCommand extends $Command<DeleteConnectionCommandInput, DeleteConnectionCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: DeleteConnectionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteConnectionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConnectionCommandInput, DeleteConnectionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteCoreNetworkRequest, DeleteCoreNetworkResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteCoreNetworkCommand}.
  */
 export interface DeleteCoreNetworkCommandInput extends DeleteCoreNetworkRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteCoreNetworkCommand}.
  */
 export interface DeleteCoreNetworkCommandOutput extends DeleteCoreNetworkResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a core network along with all core network policies. This can only be done if there are no attachments on a core network.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteCoreNetworkCommandOutput extends DeleteCoreNetworkRespons
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteCoreNetworkCommandInput - {@link DeleteCoreNetworkCommandInput}
+ * @returns {@link DeleteCoreNetworkCommandOutput}
  * @see {@link DeleteCoreNetworkCommandInput} for command's `input` shape.
  * @see {@link DeleteCoreNetworkCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface DeleteCoreNetworkCommandOutput extends DeleteCoreNetworkRespons
 export declare class DeleteCoreNetworkCommand extends $Command<DeleteCoreNetworkCommandInput, DeleteCoreNetworkCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: DeleteCoreNetworkCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteCoreNetworkCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCoreNetworkCommandInput, DeleteCoreNetworkCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteCoreNetworkPolicyVersionRequest, DeleteCoreNetworkPolicyVersionResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteCoreNetworkPolicyVersionCommand}.
  */
 export interface DeleteCoreNetworkPolicyVersionCommandInput extends DeleteCoreNetworkPolicyVersionRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteCoreNetworkPolicyVersionCommand}.
  */
 export interface DeleteCoreNetworkPolicyVersionCommandOutput extends DeleteCoreNetworkPolicyVersionResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes a policy version from a core network. You can't delete the current LIVE policy.</p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
@@ -25,6 +30,8 @@ export interface DeleteCoreNetworkPolicyVersionCommandOutput extends DeleteCoreN
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteCoreNetworkPolicyVersionCommandInput - {@link DeleteCoreNetworkPolicyVersionCommandInput}
+ * @returns {@link DeleteCoreNetworkPolicyVersionCommandOutput}
  * @see {@link DeleteCoreNetworkPolicyVersionCommandInput} for command's `input` shape.
  * @see {@link DeleteCoreNetworkPolicyVersionCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -53,11 +60,20 @@ export interface DeleteCoreNetworkPolicyVersionCommandOutput extends DeleteCoreN
 export declare class DeleteCoreNetworkPolicyVersionCommand extends $Command<DeleteCoreNetworkPolicyVersionCommandInput, DeleteCoreNetworkPolicyVersionCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: DeleteCoreNetworkPolicyVersionCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteCoreNetworkPolicyVersionCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCoreNetworkPolicyVersionCommandInput, DeleteCoreNetworkPolicyVersionCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteDeviceRequest, DeleteDeviceResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteDeviceCommand}.
  */
 export interface DeleteDeviceCommandInput extends DeleteDeviceRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteDeviceCommand}.
  */
 export interface DeleteDeviceCommandOutput extends DeleteDeviceResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes an existing device. You must first disassociate the device from any links and
  *             customer gateways.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeleteDeviceCommandOutput extends DeleteDeviceResponse, __Metad
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteDeviceCommandInput - {@link DeleteDeviceCommandInput}
+ * @returns {@link DeleteDeviceCommandOutput}
  * @see {@link DeleteDeviceCommandInput} for command's `input` shape.
  * @see {@link DeleteDeviceCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -54,11 +61,20 @@ export interface DeleteDeviceCommandOutput extends DeleteDeviceResponse, __Metad
 export declare class DeleteDeviceCommand extends $Command<DeleteDeviceCommandInput, DeleteDeviceCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: DeleteDeviceCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteDeviceCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDeviceCommandInput, DeleteDeviceCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }

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

@@ -4,16 +4,21 @@ import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as
 import { DeleteGlobalNetworkRequest, DeleteGlobalNetworkResponse } from "../models/models_0";
 import { NetworkManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../NetworkManagerClient";
 /**
+ * @public
+ *
  * The input for {@link DeleteGlobalNetworkCommand}.
  */
 export interface DeleteGlobalNetworkCommandInput extends DeleteGlobalNetworkRequest {
 }
 /**
+ * @public
+ *
  * The output of {@link DeleteGlobalNetworkCommand}.
  */
 export interface DeleteGlobalNetworkCommandOutput extends DeleteGlobalNetworkResponse, __MetadataBearer {
 }
 /**
+ * @public
  * <p>Deletes an existing global network. You must first delete all global network objects
  *             (devices, links, and sites), deregister all transit gateways, and delete any core networks.</p>
  * @example
@@ -26,6 +31,8 @@ export interface DeleteGlobalNetworkCommandOutput extends DeleteGlobalNetworkRes
  * const response = await client.send(command);
  * ```
  *
+ * @param DeleteGlobalNetworkCommandInput - {@link DeleteGlobalNetworkCommandInput}
+ * @returns {@link DeleteGlobalNetworkCommandOutput}
  * @see {@link DeleteGlobalNetworkCommandInput} for command's `input` shape.
  * @see {@link DeleteGlobalNetworkCommandOutput} for command's `response` shape.
  * @see {@link NetworkManagerClientResolvedConfig | config} for NetworkManagerClient's `config` shape.
@@ -54,11 +61,20 @@ export interface DeleteGlobalNetworkCommandOutput extends DeleteGlobalNetworkRes
 export declare class DeleteGlobalNetworkCommand extends $Command<DeleteGlobalNetworkCommandInput, DeleteGlobalNetworkCommandOutput, NetworkManagerClientResolvedConfig> {
     readonly input: DeleteGlobalNetworkCommandInput;
     static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    /**
+     * @public
+     */
     constructor(input: DeleteGlobalNetworkCommandInput);
     /**
      * @internal
      */
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: NetworkManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteGlobalNetworkCommandInput, DeleteGlobalNetworkCommandOutput>;
+    /**
+     * @internal
+     */
     private serialize;
+    /**
+     * @internal
+     */
     private deserialize;
 }