@aws-sdk/client-networkmanager 3.186.0 → 3.190.0

package/dist-es/NetworkManager.js

@@ -1,4 +1,3 @@
-import { __extends } from "tslib";
 import { AcceptAttachmentCommand, } from "./commands/AcceptAttachmentCommand";
 import { AssociateConnectPeerCommand, } from "./commands/AssociateConnectPeerCommand";
 import { AssociateCustomerGatewayCommand, } from "./commands/AssociateCustomerGatewayCommand";
@@ -85,1201 +84,1195 @@ import { UpdateNetworkResourceMetadataCommand, } from "./commands/UpdateNetworkR
 import { UpdateSiteCommand } from "./commands/UpdateSiteCommand";
 import { UpdateVpcAttachmentCommand, } from "./commands/UpdateVpcAttachmentCommand";
 import { NetworkManagerClient } from "./NetworkManagerClient";
-var NetworkManager = (function (_super) {
-    __extends(NetworkManager, _super);
-    function NetworkManager() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NetworkManager.prototype.acceptAttachment = function (args, optionsOrCb, cb) {
-        var command = new AcceptAttachmentCommand(args);
+export class NetworkManager extends NetworkManagerClient {
+    acceptAttachment(args, optionsOrCb, cb) {
+        const command = new AcceptAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.associateConnectPeer = function (args, optionsOrCb, cb) {
-        var command = new AssociateConnectPeerCommand(args);
+    }
+    associateConnectPeer(args, optionsOrCb, cb) {
+        const command = new AssociateConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.associateCustomerGateway = function (args, optionsOrCb, cb) {
-        var command = new AssociateCustomerGatewayCommand(args);
+    }
+    associateCustomerGateway(args, optionsOrCb, cb) {
+        const command = new AssociateCustomerGatewayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.associateLink = function (args, optionsOrCb, cb) {
-        var command = new AssociateLinkCommand(args);
+    }
+    associateLink(args, optionsOrCb, cb) {
+        const command = new AssociateLinkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.associateTransitGatewayConnectPeer = function (args, optionsOrCb, cb) {
-        var command = new AssociateTransitGatewayConnectPeerCommand(args);
+    }
+    associateTransitGatewayConnectPeer(args, optionsOrCb, cb) {
+        const command = new AssociateTransitGatewayConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createConnectAttachment = function (args, optionsOrCb, cb) {
-        var command = new CreateConnectAttachmentCommand(args);
+    }
+    createConnectAttachment(args, optionsOrCb, cb) {
+        const command = new CreateConnectAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createConnection = function (args, optionsOrCb, cb) {
-        var command = new CreateConnectionCommand(args);
+    }
+    createConnection(args, optionsOrCb, cb) {
+        const command = new CreateConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createConnectPeer = function (args, optionsOrCb, cb) {
-        var command = new CreateConnectPeerCommand(args);
+    }
+    createConnectPeer(args, optionsOrCb, cb) {
+        const command = new CreateConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createCoreNetwork = function (args, optionsOrCb, cb) {
-        var command = new CreateCoreNetworkCommand(args);
+    }
+    createCoreNetwork(args, optionsOrCb, cb) {
+        const command = new CreateCoreNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createDevice = function (args, optionsOrCb, cb) {
-        var command = new CreateDeviceCommand(args);
+    }
+    createDevice(args, optionsOrCb, cb) {
+        const command = new CreateDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createGlobalNetwork = function (args, optionsOrCb, cb) {
-        var command = new CreateGlobalNetworkCommand(args);
+    }
+    createGlobalNetwork(args, optionsOrCb, cb) {
+        const command = new CreateGlobalNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createLink = function (args, optionsOrCb, cb) {
-        var command = new CreateLinkCommand(args);
+    }
+    createLink(args, optionsOrCb, cb) {
+        const command = new CreateLinkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createSite = function (args, optionsOrCb, cb) {
-        var command = new CreateSiteCommand(args);
+    }
+    createSite(args, optionsOrCb, cb) {
+        const command = new CreateSiteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createSiteToSiteVpnAttachment = function (args, optionsOrCb, cb) {
-        var command = new CreateSiteToSiteVpnAttachmentCommand(args);
+    }
+    createSiteToSiteVpnAttachment(args, optionsOrCb, cb) {
+        const command = new CreateSiteToSiteVpnAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createTransitGatewayPeering = function (args, optionsOrCb, cb) {
-        var command = new CreateTransitGatewayPeeringCommand(args);
+    }
+    createTransitGatewayPeering(args, optionsOrCb, cb) {
+        const command = new CreateTransitGatewayPeeringCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createTransitGatewayRouteTableAttachment = function (args, optionsOrCb, cb) {
-        var command = new CreateTransitGatewayRouteTableAttachmentCommand(args);
+    }
+    createTransitGatewayRouteTableAttachment(args, optionsOrCb, cb) {
+        const command = new CreateTransitGatewayRouteTableAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.createVpcAttachment = function (args, optionsOrCb, cb) {
-        var command = new CreateVpcAttachmentCommand(args);
+    }
+    createVpcAttachment(args, optionsOrCb, cb) {
+        const command = new CreateVpcAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deleteAttachment = function (args, optionsOrCb, cb) {
-        var command = new DeleteAttachmentCommand(args);
+    }
+    deleteAttachment(args, optionsOrCb, cb) {
+        const command = new DeleteAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deleteConnection = function (args, optionsOrCb, cb) {
-        var command = new DeleteConnectionCommand(args);
+    }
+    deleteConnection(args, optionsOrCb, cb) {
+        const command = new DeleteConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deleteConnectPeer = function (args, optionsOrCb, cb) {
-        var command = new DeleteConnectPeerCommand(args);
+    }
+    deleteConnectPeer(args, optionsOrCb, cb) {
+        const command = new DeleteConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deleteCoreNetwork = function (args, optionsOrCb, cb) {
-        var command = new DeleteCoreNetworkCommand(args);
+    }
+    deleteCoreNetwork(args, optionsOrCb, cb) {
+        const command = new DeleteCoreNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deleteCoreNetworkPolicyVersion = function (args, optionsOrCb, cb) {
-        var command = new DeleteCoreNetworkPolicyVersionCommand(args);
+    }
+    deleteCoreNetworkPolicyVersion(args, optionsOrCb, cb) {
+        const command = new DeleteCoreNetworkPolicyVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deleteDevice = function (args, optionsOrCb, cb) {
-        var command = new DeleteDeviceCommand(args);
+    }
+    deleteDevice(args, optionsOrCb, cb) {
+        const command = new DeleteDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deleteGlobalNetwork = function (args, optionsOrCb, cb) {
-        var command = new DeleteGlobalNetworkCommand(args);
+    }
+    deleteGlobalNetwork(args, optionsOrCb, cb) {
+        const command = new DeleteGlobalNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deleteLink = function (args, optionsOrCb, cb) {
-        var command = new DeleteLinkCommand(args);
+    }
+    deleteLink(args, optionsOrCb, cb) {
+        const command = new DeleteLinkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deletePeering = function (args, optionsOrCb, cb) {
-        var command = new DeletePeeringCommand(args);
+    }
+    deletePeering(args, optionsOrCb, cb) {
+        const command = new DeletePeeringCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deleteResourcePolicy = function (args, optionsOrCb, cb) {
-        var command = new DeleteResourcePolicyCommand(args);
+    }
+    deleteResourcePolicy(args, optionsOrCb, cb) {
+        const command = new DeleteResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deleteSite = function (args, optionsOrCb, cb) {
-        var command = new DeleteSiteCommand(args);
+    }
+    deleteSite(args, optionsOrCb, cb) {
+        const command = new DeleteSiteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.deregisterTransitGateway = function (args, optionsOrCb, cb) {
-        var command = new DeregisterTransitGatewayCommand(args);
+    }
+    deregisterTransitGateway(args, optionsOrCb, cb) {
+        const command = new DeregisterTransitGatewayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.describeGlobalNetworks = function (args, optionsOrCb, cb) {
-        var command = new DescribeGlobalNetworksCommand(args);
+    }
+    describeGlobalNetworks(args, optionsOrCb, cb) {
+        const command = new DescribeGlobalNetworksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.disassociateConnectPeer = function (args, optionsOrCb, cb) {
-        var command = new DisassociateConnectPeerCommand(args);
+    }
+    disassociateConnectPeer(args, optionsOrCb, cb) {
+        const command = new DisassociateConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.disassociateCustomerGateway = function (args, optionsOrCb, cb) {
-        var command = new DisassociateCustomerGatewayCommand(args);
+    }
+    disassociateCustomerGateway(args, optionsOrCb, cb) {
+        const command = new DisassociateCustomerGatewayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.disassociateLink = function (args, optionsOrCb, cb) {
-        var command = new DisassociateLinkCommand(args);
+    }
+    disassociateLink(args, optionsOrCb, cb) {
+        const command = new DisassociateLinkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.disassociateTransitGatewayConnectPeer = function (args, optionsOrCb, cb) {
-        var command = new DisassociateTransitGatewayConnectPeerCommand(args);
+    }
+    disassociateTransitGatewayConnectPeer(args, optionsOrCb, cb) {
+        const command = new DisassociateTransitGatewayConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.executeCoreNetworkChangeSet = function (args, optionsOrCb, cb) {
-        var command = new ExecuteCoreNetworkChangeSetCommand(args);
+    }
+    executeCoreNetworkChangeSet(args, optionsOrCb, cb) {
+        const command = new ExecuteCoreNetworkChangeSetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getConnectAttachment = function (args, optionsOrCb, cb) {
-        var command = new GetConnectAttachmentCommand(args);
+    }
+    getConnectAttachment(args, optionsOrCb, cb) {
+        const command = new GetConnectAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getConnections = function (args, optionsOrCb, cb) {
-        var command = new GetConnectionsCommand(args);
+    }
+    getConnections(args, optionsOrCb, cb) {
+        const command = new GetConnectionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getConnectPeer = function (args, optionsOrCb, cb) {
-        var command = new GetConnectPeerCommand(args);
+    }
+    getConnectPeer(args, optionsOrCb, cb) {
+        const command = new GetConnectPeerCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getConnectPeerAssociations = function (args, optionsOrCb, cb) {
-        var command = new GetConnectPeerAssociationsCommand(args);
+    }
+    getConnectPeerAssociations(args, optionsOrCb, cb) {
+        const command = new GetConnectPeerAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getCoreNetwork = function (args, optionsOrCb, cb) {
-        var command = new GetCoreNetworkCommand(args);
+    }
+    getCoreNetwork(args, optionsOrCb, cb) {
+        const command = new GetCoreNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getCoreNetworkChangeEvents = function (args, optionsOrCb, cb) {
-        var command = new GetCoreNetworkChangeEventsCommand(args);
+    }
+    getCoreNetworkChangeEvents(args, optionsOrCb, cb) {
+        const command = new GetCoreNetworkChangeEventsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getCoreNetworkChangeSet = function (args, optionsOrCb, cb) {
-        var command = new GetCoreNetworkChangeSetCommand(args);
+    }
+    getCoreNetworkChangeSet(args, optionsOrCb, cb) {
+        const command = new GetCoreNetworkChangeSetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getCoreNetworkPolicy = function (args, optionsOrCb, cb) {
-        var command = new GetCoreNetworkPolicyCommand(args);
+    }
+    getCoreNetworkPolicy(args, optionsOrCb, cb) {
+        const command = new GetCoreNetworkPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getCustomerGatewayAssociations = function (args, optionsOrCb, cb) {
-        var command = new GetCustomerGatewayAssociationsCommand(args);
+    }
+    getCustomerGatewayAssociations(args, optionsOrCb, cb) {
+        const command = new GetCustomerGatewayAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getDevices = function (args, optionsOrCb, cb) {
-        var command = new GetDevicesCommand(args);
+    }
+    getDevices(args, optionsOrCb, cb) {
+        const command = new GetDevicesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getLinkAssociations = function (args, optionsOrCb, cb) {
-        var command = new GetLinkAssociationsCommand(args);
+    }
+    getLinkAssociations(args, optionsOrCb, cb) {
+        const command = new GetLinkAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getLinks = function (args, optionsOrCb, cb) {
-        var command = new GetLinksCommand(args);
+    }
+    getLinks(args, optionsOrCb, cb) {
+        const command = new GetLinksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getNetworkResourceCounts = function (args, optionsOrCb, cb) {
-        var command = new GetNetworkResourceCountsCommand(args);
+    }
+    getNetworkResourceCounts(args, optionsOrCb, cb) {
+        const command = new GetNetworkResourceCountsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getNetworkResourceRelationships = function (args, optionsOrCb, cb) {
-        var command = new GetNetworkResourceRelationshipsCommand(args);
+    }
+    getNetworkResourceRelationships(args, optionsOrCb, cb) {
+        const command = new GetNetworkResourceRelationshipsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getNetworkResources = function (args, optionsOrCb, cb) {
-        var command = new GetNetworkResourcesCommand(args);
+    }
+    getNetworkResources(args, optionsOrCb, cb) {
+        const command = new GetNetworkResourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getNetworkRoutes = function (args, optionsOrCb, cb) {
-        var command = new GetNetworkRoutesCommand(args);
+    }
+    getNetworkRoutes(args, optionsOrCb, cb) {
+        const command = new GetNetworkRoutesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getNetworkTelemetry = function (args, optionsOrCb, cb) {
-        var command = new GetNetworkTelemetryCommand(args);
+    }
+    getNetworkTelemetry(args, optionsOrCb, cb) {
+        const command = new GetNetworkTelemetryCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getResourcePolicy = function (args, optionsOrCb, cb) {
-        var command = new GetResourcePolicyCommand(args);
+    }
+    getResourcePolicy(args, optionsOrCb, cb) {
+        const command = new GetResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getRouteAnalysis = function (args, optionsOrCb, cb) {
-        var command = new GetRouteAnalysisCommand(args);
+    }
+    getRouteAnalysis(args, optionsOrCb, cb) {
+        const command = new GetRouteAnalysisCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getSites = function (args, optionsOrCb, cb) {
-        var command = new GetSitesCommand(args);
+    }
+    getSites(args, optionsOrCb, cb) {
+        const command = new GetSitesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getSiteToSiteVpnAttachment = function (args, optionsOrCb, cb) {
-        var command = new GetSiteToSiteVpnAttachmentCommand(args);
+    }
+    getSiteToSiteVpnAttachment(args, optionsOrCb, cb) {
+        const command = new GetSiteToSiteVpnAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getTransitGatewayConnectPeerAssociations = function (args, optionsOrCb, cb) {
-        var command = new GetTransitGatewayConnectPeerAssociationsCommand(args);
+    }
+    getTransitGatewayConnectPeerAssociations(args, optionsOrCb, cb) {
+        const command = new GetTransitGatewayConnectPeerAssociationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getTransitGatewayPeering = function (args, optionsOrCb, cb) {
-        var command = new GetTransitGatewayPeeringCommand(args);
+    }
+    getTransitGatewayPeering(args, optionsOrCb, cb) {
+        const command = new GetTransitGatewayPeeringCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getTransitGatewayRegistrations = function (args, optionsOrCb, cb) {
-        var command = new GetTransitGatewayRegistrationsCommand(args);
+    }
+    getTransitGatewayRegistrations(args, optionsOrCb, cb) {
+        const command = new GetTransitGatewayRegistrationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getTransitGatewayRouteTableAttachment = function (args, optionsOrCb, cb) {
-        var command = new GetTransitGatewayRouteTableAttachmentCommand(args);
+    }
+    getTransitGatewayRouteTableAttachment(args, optionsOrCb, cb) {
+        const command = new GetTransitGatewayRouteTableAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.getVpcAttachment = function (args, optionsOrCb, cb) {
-        var command = new GetVpcAttachmentCommand(args);
+    }
+    getVpcAttachment(args, optionsOrCb, cb) {
+        const command = new GetVpcAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.listAttachments = function (args, optionsOrCb, cb) {
-        var command = new ListAttachmentsCommand(args);
+    }
+    listAttachments(args, optionsOrCb, cb) {
+        const command = new ListAttachmentsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.listConnectPeers = function (args, optionsOrCb, cb) {
-        var command = new ListConnectPeersCommand(args);
+    }
+    listConnectPeers(args, optionsOrCb, cb) {
+        const command = new ListConnectPeersCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.listCoreNetworkPolicyVersions = function (args, optionsOrCb, cb) {
-        var command = new ListCoreNetworkPolicyVersionsCommand(args);
+    }
+    listCoreNetworkPolicyVersions(args, optionsOrCb, cb) {
+        const command = new ListCoreNetworkPolicyVersionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.listCoreNetworks = function (args, optionsOrCb, cb) {
-        var command = new ListCoreNetworksCommand(args);
+    }
+    listCoreNetworks(args, optionsOrCb, cb) {
+        const command = new ListCoreNetworksCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.listOrganizationServiceAccessStatus = function (args, optionsOrCb, cb) {
-        var command = new ListOrganizationServiceAccessStatusCommand(args);
+    }
+    listOrganizationServiceAccessStatus(args, optionsOrCb, cb) {
+        const command = new ListOrganizationServiceAccessStatusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.listPeerings = function (args, optionsOrCb, cb) {
-        var command = new ListPeeringsCommand(args);
+    }
+    listPeerings(args, optionsOrCb, cb) {
+        const command = new ListPeeringsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
-        var command = new ListTagsForResourceCommand(args);
+    }
+    listTagsForResource(args, optionsOrCb, cb) {
+        const command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.putCoreNetworkPolicy = function (args, optionsOrCb, cb) {
-        var command = new PutCoreNetworkPolicyCommand(args);
+    }
+    putCoreNetworkPolicy(args, optionsOrCb, cb) {
+        const command = new PutCoreNetworkPolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.putResourcePolicy = function (args, optionsOrCb, cb) {
-        var command = new PutResourcePolicyCommand(args);
+    }
+    putResourcePolicy(args, optionsOrCb, cb) {
+        const command = new PutResourcePolicyCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.registerTransitGateway = function (args, optionsOrCb, cb) {
-        var command = new RegisterTransitGatewayCommand(args);
+    }
+    registerTransitGateway(args, optionsOrCb, cb) {
+        const command = new RegisterTransitGatewayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.rejectAttachment = function (args, optionsOrCb, cb) {
-        var command = new RejectAttachmentCommand(args);
+    }
+    rejectAttachment(args, optionsOrCb, cb) {
+        const command = new RejectAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.restoreCoreNetworkPolicyVersion = function (args, optionsOrCb, cb) {
-        var command = new RestoreCoreNetworkPolicyVersionCommand(args);
+    }
+    restoreCoreNetworkPolicyVersion(args, optionsOrCb, cb) {
+        const command = new RestoreCoreNetworkPolicyVersionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.startOrganizationServiceAccessUpdate = function (args, optionsOrCb, cb) {
-        var command = new StartOrganizationServiceAccessUpdateCommand(args);
+    }
+    startOrganizationServiceAccessUpdate(args, optionsOrCb, cb) {
+        const command = new StartOrganizationServiceAccessUpdateCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.startRouteAnalysis = function (args, optionsOrCb, cb) {
-        var command = new StartRouteAnalysisCommand(args);
+    }
+    startRouteAnalysis(args, optionsOrCb, cb) {
+        const command = new StartRouteAnalysisCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.tagResource = function (args, optionsOrCb, cb) {
-        var command = new TagResourceCommand(args);
+    }
+    tagResource(args, optionsOrCb, cb) {
+        const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.untagResource = function (args, optionsOrCb, cb) {
-        var command = new UntagResourceCommand(args);
+    }
+    untagResource(args, optionsOrCb, cb) {
+        const command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.updateConnection = function (args, optionsOrCb, cb) {
-        var command = new UpdateConnectionCommand(args);
+    }
+    updateConnection(args, optionsOrCb, cb) {
+        const command = new UpdateConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.updateCoreNetwork = function (args, optionsOrCb, cb) {
-        var command = new UpdateCoreNetworkCommand(args);
+    }
+    updateCoreNetwork(args, optionsOrCb, cb) {
+        const command = new UpdateCoreNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.updateDevice = function (args, optionsOrCb, cb) {
-        var command = new UpdateDeviceCommand(args);
+    }
+    updateDevice(args, optionsOrCb, cb) {
+        const command = new UpdateDeviceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.updateGlobalNetwork = function (args, optionsOrCb, cb) {
-        var command = new UpdateGlobalNetworkCommand(args);
+    }
+    updateGlobalNetwork(args, optionsOrCb, cb) {
+        const command = new UpdateGlobalNetworkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.updateLink = function (args, optionsOrCb, cb) {
-        var command = new UpdateLinkCommand(args);
+    }
+    updateLink(args, optionsOrCb, cb) {
+        const command = new UpdateLinkCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.updateNetworkResourceMetadata = function (args, optionsOrCb, cb) {
-        var command = new UpdateNetworkResourceMetadataCommand(args);
+    }
+    updateNetworkResourceMetadata(args, optionsOrCb, cb) {
+        const command = new UpdateNetworkResourceMetadataCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.updateSite = function (args, optionsOrCb, cb) {
-        var command = new UpdateSiteCommand(args);
+    }
+    updateSite(args, optionsOrCb, cb) {
+        const command = new UpdateSiteCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    NetworkManager.prototype.updateVpcAttachment = function (args, optionsOrCb, cb) {
-        var command = new UpdateVpcAttachmentCommand(args);
+    }
+    updateVpcAttachment(args, optionsOrCb, cb) {
+        const command = new UpdateVpcAttachmentCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    };
-    return NetworkManager;
-}(NetworkManagerClient));
-export { NetworkManager };
+    }
+}